





"""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


_UpperCamelCase							=      {
    '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 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							int   ):


							'''simple docstring'''







							__lowerCamelCase      :      Any         =['''layers''', '''blocks''']
							for k in ignore_keys:
														state_dict.pop(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )


_UpperCamelCase							=      {
    '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 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Union[str, Any]   ):


							'''simple docstring'''







							__lowerCamelCase      :      List[str]         =list(s_dict.keys()   )
							for key in keys:
														__lowerCamelCase      :      Optional[Any]         =key
														for k, v in WHISPER_MAPPING.items():
																					if k in key:
																												__lowerCamelCase      :      Dict         =new_key.replace(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )

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

														__lowerCamelCase      :      Optional[Any]         =s_dict.pop(SCREAMING_SNAKE_CASE   )
							return s_dict



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Optional[Any]   ):


							'''simple docstring'''







							__lowerCamelCase    ,						__lowerCamelCase      :      Union[str, Any]         =emb.weight.shape
							__lowerCamelCase      :      Tuple         =nn.Linear(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE    ,						bias=SCREAMING_SNAKE_CASE   )
							__lowerCamelCase      :      Union[str, Any]         =emb.weight.data
							return lin_layer



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							str    ,						SCREAMING_SNAKE_CASE       :							str   ):


							'''simple docstring'''







							os.makedirs(SCREAMING_SNAKE_CASE    ,						exist_ok=SCREAMING_SNAKE_CASE   )
							__lowerCamelCase      :      Tuple         =os.path.basename(SCREAMING_SNAKE_CASE   )

							__lowerCamelCase      :      Dict         =url.split('''/'''   )[-2]
							__lowerCamelCase      :      List[Any]         =os.path.join(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )

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

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

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

							__lowerCamelCase      :      Optional[int]         =open(SCREAMING_SNAKE_CASE    ,						'''rb'''   ).read()
							if hashlib.shaaaa(SCREAMING_SNAKE_CASE   ).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 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Union[str, Any]    ,						SCREAMING_SNAKE_CASE       :							Union[str, Any]   ):


							'''simple docstring'''







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

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

							model.save_pretrained(SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
							_UpperCamelCase							=      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.')
							_UpperCamelCase							=      parser.parse_args()

							convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)











"""simple docstring"""





from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


_UpperCamelCase							=      logging.get_logger(__name__)



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Union[tf.Tensor, np.ndarray]   ):


							'''simple docstring'''







							if isinstance(SCREAMING_SNAKE_CASE    ,						np.ndarray   ):
														return list(tensor.shape   )

							__lowerCamelCase      :      Tuple         =tf.shape(SCREAMING_SNAKE_CASE   )

							if tensor.shape == tf.TensorShape(SCREAMING_SNAKE_CASE   ):
														return dynamic

							__lowerCamelCase      :      Union[str, Any]         =tensor.shape.as_list()

							return [dynamic[i] if s is None else s for i, s in enumerate(SCREAMING_SNAKE_CASE   )]



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							tf.Tensor    ,						SCREAMING_SNAKE_CASE       :							Optional[int] = None    ,						SCREAMING_SNAKE_CASE       :							Optional[str] = None   ):


							'''simple docstring'''







							return tf.nn.softmax(logits=logits + 1E-9    ,						axis=SCREAMING_SNAKE_CASE    ,						name=SCREAMING_SNAKE_CASE   )



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Optional[int]    ,						SCREAMING_SNAKE_CASE       :							int    ,						SCREAMING_SNAKE_CASE       :							Dict    ,						SCREAMING_SNAKE_CASE       :							Tuple=1E-5    ,						SCREAMING_SNAKE_CASE       :							Union[str, Any]=-1   ):


							'''simple docstring'''







							if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   ):
														raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.'''   )

							# Get mean and variance on the axis to be normalized
							__lowerCamelCase    ,						__lowerCamelCase      :      Dict         =tf.nn.moments(SCREAMING_SNAKE_CASE    ,						axes=[axis]    ,						keepdims=SCREAMING_SNAKE_CASE   )

							if axis != -1:
														# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
														# on every dimension except axis
														__lowerCamelCase      :      Dict         =[1] * inputs.shape.rank
														__lowerCamelCase      :      Dict         =shape_list(SCREAMING_SNAKE_CASE   )[axis]
														__lowerCamelCase      :      List[str]         =tf.reshape(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )
														__lowerCamelCase      :      List[str]         =tf.reshape(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )

							# Compute layer normalization using the batch_normalization
							# function.
							__lowerCamelCase      :      int         =tf.nn.batch_normalization(
							    SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE    ,						offset=SCREAMING_SNAKE_CASE    ,						scale=SCREAMING_SNAKE_CASE    ,						variance_epsilon=SCREAMING_SNAKE_CASE    ,						)
							return outputs



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							List[Any]    ,						SCREAMING_SNAKE_CASE       :							Dict=0    ,						SCREAMING_SNAKE_CASE       :							int=-1   ):


							'''simple docstring'''







							if end_dim < 0:
														end_dim += input.shape.rank
							if start_dim < 0:
														start_dim += input.shape.rank

							if start_dim == end_dim:
														return input

							__lowerCamelCase      :      List[str]         =tf.shape(SCREAMING_SNAKE_CASE   )
							__lowerCamelCase      :      Optional[Any]         =tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]   )
							__lowerCamelCase      :      int         =tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]    ,						axis=0   )
							return tf.reshape(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							tf.Tensor   ):


							'''simple docstring'''







							if not isinstance(SCREAMING_SNAKE_CASE    ,						tf.Tensor   ):
														__lowerCamelCase      :      Union[str, Any]         =tf.convert_to_tensor(SCREAMING_SNAKE_CASE   )  # Catches stray NumPy inputs
							if encoder_attention_mask.shape.rank == 3:
														__lowerCamelCase      :      str         =encoder_attention_mask[:, None, :, :]
							if encoder_attention_mask.shape.rank == 2:
														__lowerCamelCase      :      Optional[int]         =encoder_attention_mask[:, None, None, :]
							# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
							# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
							# /transformer/transformer_layers.py#L270
							# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
							# encoder_extended_attention_mask.transpose(-1, -2))
							__lowerCamelCase      :      int         =(
							    tf.cast(1    ,						encoder_attention_mask.dtype   ) - encoder_extended_attention_mask
							) * encoder_extended_attention_mask.dtype.min

							return encoder_extended_attention_mask



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							tf.Tensor    ,						SCREAMING_SNAKE_CASE       :							int    ,						SCREAMING_SNAKE_CASE       :							str = "input_ids"   ):


							'''simple docstring'''







							tf.debugging.assert_less(
							    SCREAMING_SNAKE_CASE    ,						tf.cast(SCREAMING_SNAKE_CASE    ,						dtype=tensor.dtype   )    ,						message=(
							        F'The maximum value of {tensor_name} ({tf.math.reduce_max(SCREAMING_SNAKE_CASE   )}) must be smaller than the embedding '
							        F'layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.'
							    )    ,						)



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							str    ,						SCREAMING_SNAKE_CASE       :							str    ,						SCREAMING_SNAKE_CASE       :							str   ):


							'''simple docstring'''







							__lowerCamelCase      :      Optional[int]         =64512
							# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
							# because in that case even chunking the array would not make the saving
							# possible.
							__lowerCamelCase      :      Any         =[x for x in data if len(SCREAMING_SNAKE_CASE   ) > HDF5_OBJECT_HEADER_LIMIT]

							# Expecting this to never be true.
							if bad_attributes:
														raise RuntimeError(
														    '''The following attributes cannot be saved to HDF5 file because '''
														    F'they are larger than {HDF5_OBJECT_HEADER_LIMIT} '
														    F'bytes: {bad_attributes}'   )

							__lowerCamelCase      :      Tuple         =np.asarray(SCREAMING_SNAKE_CASE   )

							__lowerCamelCase      :      Any         =1
							__lowerCamelCase      :      Optional[Any]         =np.array_split(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )

							# This will never loop forever thanks to the test above.
							while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data   ):
														num_chunks += 1
														__lowerCamelCase      :      Dict         =np.array_split(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   )

							if num_chunks > 1:
														for chunk_id, chunk_data in enumerate(SCREAMING_SNAKE_CASE   ):
																					__lowerCamelCase      :      List[Any]         =chunk_data
							else:
														__lowerCamelCase      :      Optional[int]         =data



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Optional[int]    ,						SCREAMING_SNAKE_CASE       :							Optional[int]   ):


							'''simple docstring'''







							if name in group.attrs:
														__lowerCamelCase      :      Optional[int]         =[n.decode('''utf8'''   ) if hasattr(SCREAMING_SNAKE_CASE    ,						'''decode'''   ) else n for n in group.attrs[name]]
							else:
														__lowerCamelCase      :      Tuple         =[]
														__lowerCamelCase      :      List[str]         =0
														while "%s%d" % (name, chunk_id) in group.attrs:
																					data.extend(
																					    [n.decode('''utf8'''   ) if hasattr(SCREAMING_SNAKE_CASE    ,						'''decode'''   ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]]   )
																					chunk_id += 1
							return data



def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							Dict   ):


							'''simple docstring'''







							def _expand_single_ad_tensor(SCREAMING_SNAKE_CASE       :							List[str]   ):
														if isinstance(SCREAMING_SNAKE_CASE    ,						tf.Tensor   ) and t.shape.rank == 1:
																					return tf.expand_dims(SCREAMING_SNAKE_CASE    ,						axis=-1   )
														return t

							return tf.nest.map_structure(_expand_single_ad_tensor    ,						SCREAMING_SNAKE_CASE   )




