






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


A_		:		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   snake_case (UpperCAmelCase__  )	->    int:
		UpperCamelCase_: int   				=    ['layers', 'blocks']
		for k in ignore_keys:
				state_dict.pop(UpperCAmelCase__     ,   UpperCAmelCase__  )


A_		:		Union[str, 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   snake_case (UpperCAmelCase__  )	->    List[str]:
		UpperCamelCase_: Tuple   				=    list(s_dict.keys()  )
		for key in keys:
				UpperCamelCase_: Union[str, Any]   				=    key
				for k, v in WHISPER_MAPPING.items():
						if k in key:
								UpperCamelCase_: Tuple   				=    new_key.replace(UpperCAmelCase__     ,   UpperCAmelCase__  )

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

				UpperCamelCase_: Tuple   				=    s_dict.pop(UpperCAmelCase__  )
		return s_dict

def   snake_case (UpperCAmelCase__  )	->    List[str]:
		UpperCamelCase_				,UpperCamelCase_: Optional[int]   				=    emb.weight.shape
		UpperCamelCase_: List[Any]   				=    nn.Linear(UpperCAmelCase__     ,   UpperCAmelCase__     ,   bias=UpperCAmelCase__  )
		UpperCamelCase_: Union[str, Any]   				=    emb.weight.data
		return lin_layer

def   snake_case (UpperCAmelCase__     ,   UpperCAmelCase__  )	->    bytes:
		os.makedirs(UpperCAmelCase__     ,   exist_ok=UpperCAmelCase__  )
		UpperCamelCase_: List[str]   				=    os.path.basename(UpperCAmelCase__  )

		UpperCamelCase_: List[Any]   				=    url.split('/'  )[-2]
		UpperCamelCase_: Union[str, Any]   				=    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__  ):
				UpperCamelCase_: List[Any]   				=    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=8_0     ,   unit='iB'     ,   unit_scale=UpperCAmelCase__     ,   unit_divisor=1_0_2_4  ) as loop:
						while True:
								UpperCamelCase_: Any   				=    source.read(8_1_9_2  )
								if not buffer:
										break

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

		UpperCamelCase_: 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   snake_case (UpperCAmelCase__     ,   UpperCAmelCase__  )	->    List[Any]:
		if ".pt" not in checkpoint_path:
				UpperCamelCase_: Union[str, Any]   				=    _download(_MODELS[checkpoint_path]  )
		else:
				UpperCamelCase_: Optional[int]   				=    torch.load(UpperCAmelCase__     ,   map_location='cpu'  )
		UpperCamelCase_: Union[str, Any]   				=    original_checkpoint['dims']
		UpperCamelCase_: List[str]   				=    original_checkpoint['model_state_dict']
		UpperCamelCase_: Optional[int]   				=    state_dict['decoder.token_embedding.weight']
		remove_ignore_keys_(UpperCAmelCase__  )
		rename_keys(UpperCAmelCase__  )
		UpperCamelCase_: List[str]   				=    True
		UpperCamelCase_: int   				=    state_dict['decoder.layers.0.fc1.weight'].shape[0]

		UpperCamelCase_: 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']     ,   )

		UpperCamelCase_: Any   				=    WhisperForConditionalGeneration(UpperCAmelCase__  )
		UpperCamelCase_				,UpperCamelCase_: Optional[int]   				=    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:
				UpperCamelCase_: str   				=    make_linear_from_emb(model.model.decoder.embed_tokens  )
		else:
				UpperCamelCase_: Tuple   				=    proj_out_weights

		model.save_pretrained(UpperCAmelCase__  )


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

			convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A_		:		List[Any]		     =			logging.get_logger(__name__)

A_		:		Optional[Any]		     =			{
    'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json',
    'YituTech/conv-bert-medium-small': (
        'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json'
    ),
    'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json',
    # See all ConvBERT models at https://huggingface.co/models?filter=convbert
}




class     _lowerCAmelCase(	UpperCAmelCase_ ):





       """simple docstring"""







       a    :		str									='''convbert'''





       def __init__( self  ,      _lowerCamelCase=3_0_5_2_2  ,      _lowerCamelCase=7_6_8  ,      _lowerCamelCase=1_2  ,      _lowerCamelCase=1_2  ,      _lowerCamelCase=3_0_7_2  ,      _lowerCamelCase="gelu"  ,      _lowerCamelCase=0.1  ,      _lowerCamelCase=0.1  ,      _lowerCamelCase=5_1_2  ,      _lowerCamelCase=2  ,      _lowerCamelCase=0.0_2  ,      _lowerCamelCase=1e-12  ,      _lowerCamelCase=1  ,      _lowerCamelCase=0  ,      _lowerCamelCase=2  ,      _lowerCamelCase=7_6_8  ,      _lowerCamelCase=2  ,      _lowerCamelCase=9  ,      _lowerCamelCase=1  ,      _lowerCamelCase=None  ,      **_lowerCamelCase  ,      ):
         super().__init__(
             pad_token_id=_lowerCamelCase  ,      bos_token_id=_lowerCamelCase  ,      eos_token_id=_lowerCamelCase  ,      **_lowerCamelCase  ,      )

         UpperCamelCase_: Dict   				=    vocab_size
         UpperCamelCase_: Tuple   				=    hidden_size
         UpperCamelCase_: Optional[int]   				=    num_hidden_layers
         UpperCamelCase_: Optional[int]   				=    num_attention_heads
         UpperCamelCase_: Optional[Any]   				=    intermediate_size
         UpperCamelCase_: Tuple   				=    hidden_act
         UpperCamelCase_: Any   				=    hidden_dropout_prob
         UpperCamelCase_: Any   				=    attention_probs_dropout_prob
         UpperCamelCase_: List[Any]   				=    max_position_embeddings
         UpperCamelCase_: List[Any]   				=    type_vocab_size
         UpperCamelCase_: Optional[int]   				=    initializer_range
         UpperCamelCase_: Tuple   				=    layer_norm_eps
         UpperCamelCase_: List[str]   				=    embedding_size
         UpperCamelCase_: int   				=    head_ratio
         UpperCamelCase_: Dict   				=    conv_kernel_size
         UpperCamelCase_: List[Any]   				=    num_groups
         UpperCamelCase_: Dict   				=    classifier_dropout







class     _lowerCAmelCase(	UpperCAmelCase_ ):





       """simple docstring"""







       @property
       def       _a   ( self							):
         if self.task == "multiple-choice":
           UpperCamelCase_: Dict   				=    {0: 'batch', 1: 'choice', 2: 'sequence'}
         else:
           UpperCamelCase_: Dict   				=    {0: 'batch', 1: 'sequence'}
         return OrderedDict(
             [
                 ('input_ids', dynamic_axis),
                 ('attention_mask', dynamic_axis),
                 ('token_type_ids', dynamic_axis),
             ]							)