




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      :  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 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''
				_lowerCAmelCase    :    Any										=      ["""layers""", """blocks"""]
				for k in ignore_keys:
								state_dict.pop(UpperCamelCase_      ,    UpperCamelCase_       )


_lowerCamelCase      :  List[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 							_UpperCAmelCase  (UpperCamelCase_ : Any       ):
				'''simple docstring'''
				_lowerCAmelCase    :    int										=      list(s_dict.keys()       )
				for key in keys:
								_lowerCAmelCase    :    Optional[int]										=      key
								for k, v in WHISPER_MAPPING.items():
												if k in key:
																_lowerCAmelCase    :    List[str]										=      new_key.replace(UpperCamelCase_      ,    UpperCamelCase_       )

								print(F"{key} -> {new_key}"       )

								_lowerCAmelCase    :    List[Any]										=      s_dict.pop(UpperCamelCase_       )
				return s_dict




def 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''
				_lowerCAmelCase					,    _lowerCAmelCase    :    Any										=      emb.weight.shape
				_lowerCAmelCase    :    str										=      nn.Linear(UpperCamelCase_      ,    UpperCamelCase_      ,    bias=UpperCamelCase_       )
				_lowerCAmelCase    :    Optional[int]										=      emb.weight.data
				return lin_layer




def 							_UpperCAmelCase  (UpperCamelCase_ : str      ,    UpperCamelCase_ : str       ):
				'''simple docstring'''
				os.makedirs(UpperCamelCase_      ,    exist_ok=UpperCamelCase_       )
				_lowerCAmelCase    :    Optional[Any]										=      os.path.basename(UpperCamelCase_       )

				_lowerCAmelCase    :    Tuple										=      url.split("""/"""       )[-2]
				_lowerCAmelCase    :    int										=      os.path.join(UpperCamelCase_      ,    UpperCamelCase_       )

				if os.path.exists(UpperCamelCase_       ) and not os.path.isfile(UpperCamelCase_       ):
								raise RuntimeError(F"{download_target} exists and is not a regular file"       )

				if os.path.isfile(UpperCamelCase_       ):
								_lowerCAmelCase    :    int										=      open(UpperCamelCase_      ,    """rb"""       ).read()
								if hashlib.shaaaa(UpperCamelCase_       ).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(UpperCamelCase_       ) as source, open(UpperCamelCase_      ,    """wb"""       ) as output:
								with tqdm(
								    total=int(source.info().get("""Content-Length"""       )       )      ,    ncols=80      ,    unit="""iB"""      ,    unit_scale=UpperCamelCase_      ,    unit_divisor=1024       ) as loop:
												while True:
																_lowerCAmelCase    :    List[str]										=      source.read(8192       )
																if not buffer:
																				break

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

				_lowerCAmelCase    :    Union[str, Any]										=      open(UpperCamelCase_      ,    """rb"""       ).read()
				if hashlib.shaaaa(UpperCamelCase_       ).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 							_UpperCAmelCase  (UpperCamelCase_ : List[Any]      ,    UpperCamelCase_ : Dict       ):
				'''simple docstring'''
				if ".pt" not in checkpoint_path:
								_lowerCAmelCase    :    Any										=      _download(_MODELS[checkpoint_path]       )
				else:
								_lowerCAmelCase    :    Union[str, Any]										=      torch.load(UpperCamelCase_      ,    map_location="""cpu"""       )
				_lowerCAmelCase    :    Dict										=      original_checkpoint["""dims"""]
				_lowerCAmelCase    :    Tuple										=      original_checkpoint["""model_state_dict"""]
				_lowerCAmelCase    :    List[str]										=      state_dict["""decoder.token_embedding.weight"""]
				remove_ignore_keys_(UpperCamelCase_       )
				rename_keys(UpperCamelCase_       )
				_lowerCAmelCase    :    List[str]										=      True
				_lowerCAmelCase    :    Optional[int]										=      state_dict["""decoder.layers.0.fc1.weight"""].shape[0]

				_lowerCAmelCase    :    Dict										=      WhisperConfig(
				    vocab_size=dimensions["""n_vocab"""]      ,    encoder_ffn_dim=UpperCamelCase_      ,    decoder_ffn_dim=UpperCamelCase_      ,    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    :    List[Any]										=      WhisperForConditionalGeneration(UpperCamelCase_       )
				_lowerCAmelCase					,    _lowerCAmelCase    :    List[str]										=      model.model.load_state_dict(UpperCamelCase_      ,    strict=UpperCamelCase_       )
				if len(UpperCamelCase_       ) > 0 and not set(UpperCamelCase_       ) <= {
				    "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    :    List[str]										=      make_linear_from_emb(model.model.decoder.embed_tokens       )
				else:
								_lowerCAmelCase    :    Dict										=      proj_out_weights

				model.save_pretrained(UpperCamelCase_       )


if __name__ == "__main__":
	_lowerCamelCase      :  Union[str, Any]      						=						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      :  str      						=						parser.parse_args()

	convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)







from __future__ import annotations

from decimal import Decimal

from numpy import array




def 							_UpperCAmelCase  (UpperCamelCase_ : list[list[float]]       ):
				'''simple docstring'''
				_lowerCAmelCase    :    int										=      Decimal

				# Check if the provided matrix has 2 rows and 2 columns
				# since this implementation only works for 2x2 matrices
				if len(UpperCamelCase_       ) == 2 and len(matrix[0]       ) == 2 and len(matrix[1]       ) == 2:
								# Calculate the determinant of the matrix
								_lowerCAmelCase    :    Optional[Any]										=      float(
								    d(matrix[0][0]       ) * d(matrix[1][1]       ) - d(matrix[1][0]       ) * d(matrix[0][1]       )       )
								if determinant == 0:
												raise ValueError("""This matrix has no inverse."""       )

								# Creates a copy of the matrix with swapped positions of the elements
								_lowerCAmelCase    :    Union[str, Any]										=      [[0.0, 0.0], [0.0, 0.0]]
								_lowerCAmelCase					,    _lowerCAmelCase    :    Any										=      matrix[1][1], matrix[0][0]
								_lowerCAmelCase					,    _lowerCAmelCase    :    Optional[Any]										=      -matrix[1][0], -matrix[0][1]

								# Calculate the inverse of the matrix
								return [
								    [(float(d(UpperCamelCase_       )       ) / determinant) or 0.0 for n in row] for row in swapped_matrix
								]
				elif (
				    len(UpperCamelCase_       ) == 3
				    and len(matrix[0]       ) == 3
				    and len(matrix[1]       ) == 3
				    and len(matrix[2]       ) == 3
				):
								# Calculate the determinant of the matrix using Sarrus rule
								_lowerCAmelCase    :    List[str]										=      float(
								    (
								        (d(matrix[0][0]       ) * d(matrix[1][1]       ) * d(matrix[2][2]       ))
								        + (d(matrix[0][1]       ) * d(matrix[1][2]       ) * d(matrix[2][0]       ))
								        + (d(matrix[0][2]       ) * d(matrix[1][0]       ) * d(matrix[2][1]       ))
								    )
								    - (
								        (d(matrix[0][2]       ) * d(matrix[1][1]       ) * d(matrix[2][0]       ))
								        + (d(matrix[0][1]       ) * d(matrix[1][0]       ) * d(matrix[2][2]       ))
								        + (d(matrix[0][0]       ) * d(matrix[1][2]       ) * d(matrix[2][1]       ))
								    )       )
								if determinant == 0:
												raise ValueError("""This matrix has no inverse."""       )

								# Creating cofactor matrix
								_lowerCAmelCase    :    Optional[Any]										=      [
								    [d(0.0       ), d(0.0       ), d(0.0       )],
								    [d(0.0       ), d(0.0       ), d(0.0       )],
								    [d(0.0       ), d(0.0       ), d(0.0       )],
								]
								_lowerCAmelCase    :    Optional[Any]										=      (d(matrix[1][1]       ) * d(matrix[2][2]       )) - (
								    d(matrix[1][2]       ) * d(matrix[2][1]       )
								)
								_lowerCAmelCase    :    str										=      -(
								    (d(matrix[1][0]       ) * d(matrix[2][2]       )) - (d(matrix[1][2]       ) * d(matrix[2][0]       ))
								)
								_lowerCAmelCase    :    Any										=      (d(matrix[1][0]       ) * d(matrix[2][1]       )) - (
								    d(matrix[1][1]       ) * d(matrix[2][0]       )
								)
								_lowerCAmelCase    :    List[str]										=      -(
								    (d(matrix[0][1]       ) * d(matrix[2][2]       )) - (d(matrix[0][2]       ) * d(matrix[2][1]       ))
								)
								_lowerCAmelCase    :    Tuple										=      (d(matrix[0][0]       ) * d(matrix[2][2]       )) - (
								    d(matrix[0][2]       ) * d(matrix[2][0]       )
								)
								_lowerCAmelCase    :    Any										=      -(
								    (d(matrix[0][0]       ) * d(matrix[2][1]       )) - (d(matrix[0][1]       ) * d(matrix[2][0]       ))
								)
								_lowerCAmelCase    :    int										=      (d(matrix[0][1]       ) * d(matrix[1][2]       )) - (
								    d(matrix[0][2]       ) * d(matrix[1][1]       )
								)
								_lowerCAmelCase    :    Optional[Any]										=      -(
								    (d(matrix[0][0]       ) * d(matrix[1][2]       )) - (d(matrix[0][2]       ) * d(matrix[1][0]       ))
								)
								_lowerCAmelCase    :    Tuple										=      (d(matrix[0][0]       ) * d(matrix[1][1]       )) - (
								    d(matrix[0][1]       ) * d(matrix[1][0]       )
								)

								# Transpose the cofactor matrix (Adjoint matrix)
								_lowerCAmelCase    :    List[str]										=      array(UpperCamelCase_       )
								for i in range(3       ):
												for j in range(3       ):
																_lowerCAmelCase    :    List[Any]										=      cofactor_matrix[j][i]

        # Inverse of the matrix using the formula (1/determinant) * adjoint matrix
								_lowerCAmelCase    :    Tuple										=      array(UpperCamelCase_       )
								for i in range(3       ):
												for j in range(3       ):
																inverse_matrix[i][j] /= d(UpperCamelCase_       )

        # Calculate the inverse of the matrix
								return [[float(d(UpperCamelCase_       )       ) or 0.0 for n in row] for row in inverse_matrix]
				raise ValueError("""Please provide a matrix of size 2x2 or 3x3."""       )

