


'''simple docstring'''







import argparse
import hashlib
import os
import urllib
import warnings

import torch
from torch import nn
from tqdm import tqdm

from transformers import WhisperConfig, WhisperForConditionalGeneration


lowerCAmelCase     :  Union[str, Any]											=    {
    """tiny.en""": """https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt""",
    """tiny""": """https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt""",
    """base.en""": """https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt""",
    """base""": """https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt""",
    """small.en""": """https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt""",
    """small""": """https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt""",
    """medium.en""": """https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt""",
    """medium""": """https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt""",
    """large""": """https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt""",
    """large-v2""": """https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt""",
}






def       lowercase					(_A       ):







       """simple docstring"""







       _lowerCAmelCase     :				List[str]       =							['layers', 'blocks']
       for k in ignore_keys:
              state_dict.pop(_A ,    _A       )


lowerCAmelCase     :  Any											=    {
    """blocks""": """layers""",
    """mlp.0""": """fc1""",
    """mlp.2""": """fc2""",
    """mlp_ln""": """final_layer_norm""",
    """.attn.query""": """.self_attn.q_proj""",
    """.attn.key""": """.self_attn.k_proj""",
    """.attn.value""": """.self_attn.v_proj""",
    """.attn_ln""": """.self_attn_layer_norm""",
    """.attn.out""": """.self_attn.out_proj""",
    """.cross_attn.query""": """.encoder_attn.q_proj""",
    """.cross_attn.key""": """.encoder_attn.k_proj""",
    """.cross_attn.value""": """.encoder_attn.v_proj""",
    """.cross_attn_ln""": """.encoder_attn_layer_norm""",
    """.cross_attn.out""": """.encoder_attn.out_proj""",
    """decoder.ln.""": """decoder.layer_norm.""",
    """encoder.ln.""": """encoder.layer_norm.""",
    """token_embedding""": """embed_tokens""",
    """encoder.positional_embedding""": """encoder.embed_positions.weight""",
    """decoder.positional_embedding""": """decoder.embed_positions.weight""",
    """ln_post""": """layer_norm""",
}






def       lowercase					(_A       ):







       """simple docstring"""







       _lowerCAmelCase     :				int       =							list(s_dict.keys()       )
       for key in keys:
              _lowerCAmelCase     :				Dict       =							key
              for k, v in WHISPER_MAPPING.items():
                     if k in key:
                            _lowerCAmelCase     :				List[Any]       =							new_key.replace(_A ,    _A       )

              print(f'{key} -> {new_key}'       )

              _lowerCAmelCase     :				List[str]       =							s_dict.pop(_A       )
       return s_dict






def       lowercase					(_A       ):







       """simple docstring"""







       _lowerCAmelCase      ,  _lowerCAmelCase     :				str       =							emb.weight.shape
       _lowerCAmelCase     :				int       =							nn.Linear(_A ,    _A ,    bias=_A       )
       _lowerCAmelCase     :				int       =							emb.weight.data
       return lin_layer






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       os.makedirs(_A ,    exist_ok=_A       )
       _lowerCAmelCase     :				Optional[Any]       =							os.path.basename(_A       )

       _lowerCAmelCase     :				str       =							url.split('/'       )[-2]
       _lowerCAmelCase     :				Optional[Any]       =							os.path.join(_A ,    _A       )

       if os.path.exists(_A       ) and not os.path.isfile(_A       ):
              raise RuntimeError(f'{download_target} exists and is not a regular file'       )

       if os.path.isfile(_A       ):
              _lowerCAmelCase     :				Optional[int]       =							open(_A ,    'rb'       ).read()
              if hashlib.shaaaa(_A       ).hexdigest() == expected_shaaaa:
                     return model_bytes
              else:
                     warnings.warn(f'{download_target} exists, but the SHA256 checksum does not match; re-downloading the file'       )

       with urllib.request.urlopen(_A       ) as source, open(_A ,    'wb'       ) as output:
              with tqdm(
                  total=int(source.info().get('Content-Length'       )       ) ,    ncols=8_0 ,    unit='iB' ,    unit_scale=_A ,    unit_divisor=1_0_2_4       ) as loop:
                     while True:
                            _lowerCAmelCase     :				Tuple       =							source.read(8_1_9_2       )
                            if not buffer:
                                   break

                            output.write(_A       )
                            loop.update(len(_A       )       )

       _lowerCAmelCase     :				Dict       =							open(_A ,    'rb'       ).read()
       if hashlib.shaaaa(_A       ).hexdigest() != expected_shaaaa:
              raise RuntimeError(
                  'Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model.'       )

       return model_bytes






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if ".pt" not in checkpoint_path:
              _lowerCAmelCase     :				str       =							_download(_MODELS[checkpoint_path]       )
       else:
              _lowerCAmelCase     :				Optional[Any]       =							torch.load(_A ,    map_location='cpu'       )
       _lowerCAmelCase     :				str       =							original_checkpoint['dims']
       _lowerCAmelCase     :				List[Any]       =							original_checkpoint['model_state_dict']
       _lowerCAmelCase     :				Union[str, Any]       =							state_dict['decoder.token_embedding.weight']
       remove_ignore_keys_(_A       )
       rename_keys(_A       )
       _lowerCAmelCase     :				Any       =							True
       _lowerCAmelCase     :				Union[str, Any]       =							state_dict['decoder.layers.0.fc1.weight'].shape[0]

       _lowerCAmelCase     :				str       =							WhisperConfig(
           vocab_size=dimensions['n_vocab'] ,    encoder_ffn_dim=_A ,    decoder_ffn_dim=_A ,    num_mel_bins=dimensions['n_mels'] ,    d_model=dimensions['n_audio_state'] ,    max_target_positions=dimensions['n_text_ctx'] ,    encoder_layers=dimensions['n_audio_layer'] ,    encoder_attention_heads=dimensions['n_audio_head'] ,    decoder_layers=dimensions['n_text_layer'] ,    decoder_attention_heads=dimensions['n_text_state'] ,    max_source_positions=dimensions['n_audio_ctx'] ,    )

       _lowerCAmelCase     :				int       =							WhisperForConditionalGeneration(_A       )
       _lowerCAmelCase      ,  _lowerCAmelCase     :				str       =							model.model.load_state_dict(_A ,    strict=_A       )
       if len(_A       ) > 0 and not set(_A       ) <= {
           "encoder.embed_positions.weights",
           "decoder.embed_positions.weights",
       }:
              raise ValueError(
                  'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,'
                  f' but all the following weights are missing {missing}'       )

       if tie_embeds:
              _lowerCAmelCase     :				Tuple       =							make_linear_from_emb(model.model.decoder.embed_tokens       )
       else:
              _lowerCAmelCase     :				List[str]       =							proj_out_weights

       model.save_pretrained(_A       )


if __name__ == "__main__":
       lowerCAmelCase     :  Tuple											=    argparse.ArgumentParser()
       # # Required parameters
       parser.add_argument("""--checkpoint_path""", type=str, help="""Patht to the downloaded checkpoints""")
       parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
       lowerCAmelCase     :  Union[str, Any]											=    parser.parse_args()

       convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)





'''simple docstring'''







from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand






def       lowercase					(_A       ):







       """simple docstring"""







       return ConvertCommand(
           args.model_type ,    args.tf_checkpoint ,    args.pytorch_dump_output ,    args.config ,    args.finetuning_task_name       )


lowerCAmelCase     :  Optional[int]											=    """
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
"""
class 						UpperCamelCase__       (			SCREAMING_SNAKE_CASE_						):



     """simple docstring"""






     @staticmethod
     def a						(			snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				str       =							parser.add_parser(
                'convert'   ,						help='CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.'   ,						)
            train_parser.add_argument('--model_type'   ,						type=snake_case__   ,						required=snake_case__   ,						help='Model\'s type.' )
            train_parser.add_argument(
                '--tf_checkpoint'   ,						type=snake_case__   ,						required=snake_case__   ,						help='TensorFlow checkpoint path or folder.' )
            train_parser.add_argument(
                '--pytorch_dump_output'   ,						type=snake_case__   ,						required=snake_case__   ,						help='Path to the PyTorch saved model output.' )
            train_parser.add_argument('--config'   ,						type=snake_case__   ,						default=''   ,						help='Configuration file path or folder.' )
            train_parser.add_argument(
                '--finetuning_task_name'   ,						type=snake_case__   ,						default=snake_case__   ,						help='Optional fine-tuning task name if the TF model was a finetuned model.'   ,						)
            train_parser.set_defaults(func=snake_case__ )







     def __init__(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						*snake_case__   ,						):

            '''simple docstring'''

            _lowerCAmelCase     :				str       =							logging.get_logger('transformers-cli/converting' )

            self._logger.info(F'Loading model {model_type}' )
            _lowerCAmelCase     :				Any       =							model_type
            _lowerCAmelCase     :				Any       =							tf_checkpoint
            _lowerCAmelCase     :				List[str]       =							pytorch_dump_output
            _lowerCAmelCase     :				int       =							config
            _lowerCAmelCase     :				str       =							finetuning_task_name







     def a						(			self ):

            '''simple docstring'''

            if self._model_type == "albert":
                   try:
                          from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
                              convert_tf_checkpoint_to_pytorch,
                          )
                   except ImportError:
                          raise ImportError(snake_case__ )

                   convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            elif self._model_type == "bert":
                   try:
                          from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
                              convert_tf_checkpoint_to_pytorch,
                          )
                   except ImportError:
                          raise ImportError(snake_case__ )

                   convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            elif self._model_type == "funnel":
                   try:
                          from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
                              convert_tf_checkpoint_to_pytorch,
                          )
                   except ImportError:
                          raise ImportError(snake_case__ )

                   convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            elif self._model_type == "t5":
                   try:
                          from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
                   except ImportError:
                          raise ImportError(snake_case__ )

                   convert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            elif self._model_type == "gpt":
                   from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
                       convert_openai_checkpoint_to_pytorch,
                   )

                   convert_openai_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            elif self._model_type == "transfo_xl":
                   try:
                          from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
                              convert_transfo_xl_checkpoint_to_pytorch,
                          )
                   except ImportError:
                          raise ImportError(snake_case__ )

                   if "ckpt" in self._tf_checkpoint.lower():
                          _lowerCAmelCase     :				List[Any]       =							self._tf_checkpoint
                          _lowerCAmelCase     :				Optional[int]       =							''
                   else:
                          _lowerCAmelCase     :				int       =							self._tf_checkpoint
                          _lowerCAmelCase     :				Dict       =							''
                   convert_transfo_xl_checkpoint_to_pytorch(
                       snake_case__   ,						self._config   ,						self._pytorch_dump_output   ,						snake_case__ )
            elif self._model_type == "gpt2":
                   try:
                          from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
                              convert_gpta_checkpoint_to_pytorch,
                          )
                   except ImportError:
                          raise ImportError(snake_case__ )

                   convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            elif self._model_type == "xlnet":
                   try:
                          from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
                              convert_xlnet_checkpoint_to_pytorch,
                          )
                   except ImportError:
                          raise ImportError(snake_case__ )

                   convert_xlnet_checkpoint_to_pytorch(
                       self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output   ,						self._finetuning_task_name )
            elif self._model_type == "xlm":
                   from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
                       convert_xlm_checkpoint_to_pytorch,
                   )

                   convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._pytorch_dump_output )
            elif self._model_type == "lxmert":
                   from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
                       convert_lxmert_checkpoint_to_pytorch,
                   )

                   convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._pytorch_dump_output )
            elif self._model_type == "rembert":
                   from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
                       convert_rembert_tf_checkpoint_to_pytorch,
                   )

                   convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint   ,						self._config   ,						self._pytorch_dump_output )
            else:
                   raise ValueError(
                       '--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]' )

