


'''simple docstring'''


import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    HubertConfig,
    HubertForCTC,
    HubertModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
_UpperCamelCase 							=  logging.get_logger(__name__)

_UpperCamelCase 							=  {
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
    "fc2": "encoder.layers.*.feed_forward.output_dense",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "w2v_encoder.proj": "lm_head",
    "mask_emb": "masked_spec_embed",
}


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     for attribute in key.split("."							):
          __A	:       Union[str, Any]      =							getattr(UpperCamelCase_       ,					UpperCamelCase_							)

     if weight_type is not None:
          __A	:       int      =							getattr(UpperCamelCase_       ,					UpperCamelCase_							).shape
     else:
          __A	:       Any      =							hf_pointer.shape

     assert hf_shape == value.shape, (
         f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
         f" {value.shape} for {full_name}"
     )

     if weight_type == "weight":
          __A	:       Optional[int]      =							value
     elif weight_type == "weight_g":
          __A	:       Optional[Any]      =							value
     elif weight_type == "weight_v":
          __A	:       Optional[int]      =							value
     elif weight_type == "bias":
          __A	:       Tuple      =							value
     else:
          __A	:       Dict      =							value

     logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."							)


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       Union[str, Any]      =							[]
     __A	:       Dict      =							fairseq_model.state_dict()

     __A	:       List[Any]      =							hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor

     for name, value in fairseq_dict.items():
          __A	:       str      =							False
          if "conv_layers" in name:
               load_conv_layer(
                   UpperCamelCase_       ,					UpperCamelCase_       ,					UpperCamelCase_       ,					UpperCamelCase_       ,					hf_model.config.feat_extract_norm == "group"       ,					)
               __A	:       Optional[Any]      =							True
          else:
               for key, mapped_key in MAPPING.items():
                    __A	:       Tuple      =							"hubert." + mapped_key if (is_finetuned and mapped_key != "lm_head") else mapped_key

                    if key in name or (key.split("w2v_model."							)[-1] == name.split("."							)[0] and not is_finetuned):
                         __A	:       Union[str, Any]      =							True
                         if "*" in mapped_key:
                              __A	:       List[Any]      =							name.split(UpperCamelCase_							)[0].split("."							)[-2]
                              __A	:       Union[str, Any]      =							mapped_key.replace("*"       ,					UpperCamelCase_							)
                         if "weight_g" in name:
                              __A	:       Any      =							"weight_g"
                         elif "weight_v" in name:
                              __A	:       Dict      =							"weight_v"
                         elif "weight" in name:
                              __A	:       str      =							"weight"
                         elif "bias" in name:
                              __A	:       Tuple      =							"bias"
                         else:
                              __A	:       Optional[Any]      =							None
                         set_recursively(UpperCamelCase_       ,					UpperCamelCase_       ,					UpperCamelCase_       ,					UpperCamelCase_       ,					UpperCamelCase_							)
                    continue
          if not is_used:
               unused_weights.append(UpperCamelCase_							)

     logger.warning(f"Unused weights: {unused_weights}"							)


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       Optional[int]      =							full_name.split("conv_layers."							)[-1]
     __A	:       Dict      =							name.split("."							)
     __A	:       List[str]      =							int(items[0]							)
     __A	:       Any      =							int(items[1]							)

     if type_id == 0:
          if "bias" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
                   f"{full_name} has size {value.shape}, but"
                   f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
               )
               __A	:       Any      =							value
               logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."							)
          elif "weight" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
                   f"{full_name} has size {value.shape}, but"
                   f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
               )
               __A	:       List[Any]      =							value
               logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."							)
     elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
          if "bias" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
                   f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
                   " found."
               )
               __A	:       Optional[Any]      =							value
               logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."							)
          elif "weight" in name:
               assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
                   f"{full_name} has size {value.shape}, but"
                   f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
               )
               __A	:       Optional[int]      =							value
               logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."							)
     else:
          unused_weights.append(UpperCamelCase_							)


@torch.no_grad()
def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE=None       ,					SCREAMING_SNAKE_CASE=None       ,					SCREAMING_SNAKE_CASE=True							):




     '''simple docstring'''





     if config_path is not None:
          __A	:       Dict      =							HubertConfig.from_pretrained(UpperCamelCase_							)
     else:
          __A	:       Tuple      =							HubertConfig()

     if is_finetuned:
          if dict_path:
               __A	:       str      =							Dictionary.load(UpperCamelCase_							)

               # important change bos & pad token id since CTC symbol is <pad> and
               # not <s> as in fairseq
               __A	:       Tuple      =							target_dict.pad_index
               __A	:       str      =							target_dict.bos_index
               __A	:       Union[str, Any]      =							target_dict.eos_index
               __A	:       List[Any]      =							len(target_dict.symbols							)
               __A	:       List[Any]      =							os.path.join(UpperCamelCase_       ,					"vocab.json"							)
               if not os.path.isdir(UpperCamelCase_							):
                    logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(UpperCamelCase_							)							)
                    return
               os.makedirs(UpperCamelCase_       ,					exist_ok=UpperCamelCase_							)
               with open(UpperCamelCase_       ,					"w"       ,					encoding="utf-8"							) as vocab_handle:
                    json.dump(target_dict.indices       ,					UpperCamelCase_							)
               __A	:       Tuple      =							WavaVecaCTCTokenizer(
                   UpperCamelCase_       ,					unk_token=target_dict.unk_word       ,					pad_token=target_dict.pad_word       ,					bos_token=target_dict.bos_word       ,					eos_token=target_dict.eos_word       ,					word_delimiter_token="|"       ,					do_lower_case=UpperCamelCase_       ,					)
               __A	:       List[str]      =							True if config.feat_extract_norm == "layer" else False
               __A	:       Optional[Any]      =							WavaVecaFeatureExtractor(
                   feature_size=1       ,					sampling_rate=1_6000       ,					padding_value=0       ,					do_normalize=UpperCamelCase_       ,					return_attention_mask=UpperCamelCase_       ,					)
               __A	:       Dict      =							WavaVecaProcessor(feature_extractor=UpperCamelCase_       ,					tokenizer=UpperCamelCase_							)
               processor.save_pretrained(UpperCamelCase_							)

          __A	:       Tuple      =							HubertForCTC(UpperCamelCase_							)
     else:
          __A	:       str      =							HubertModel(UpperCamelCase_							)

     if is_finetuned:
          __A  ,__A  ,__A	:       Any      =							fairseq.checkpoint_utils.load_model_ensemble_and_task(
              [checkpoint_path]       ,					arg_overrides={"data": "/".join(dict_path.split("/"							)[:-1]							)}							)
     else:
          __A  ,__A  ,__A	:       int      =							fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]							)

     __A	:       Union[str, Any]      =							model[0].eval()

     recursively_load_weights(UpperCamelCase_       ,					UpperCamelCase_       ,					UpperCamelCase_							)

     hf_wavavec.save_pretrained(UpperCamelCase_							)


if __name__ == "__main__":
      _UpperCamelCase 							=  argparse.ArgumentParser()
      parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
      parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
      parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
      parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
      parser.add_argument(
          """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
      )
      _UpperCamelCase 							=  parser.parse_args()
      convert_hubert_checkpoint(
          args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
      )





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)




