



import random
import unittest

import numpy as np

import transformers
from transformers import is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax


if is_flax_available():
				import os

				import jax.numpy as jnp
				from jax import jit

				from transformers import AutoTokenizer, FlaxAutoModelForCausalLM
				from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model

				_lowercase     							=						'''0.12'''  # assumed parallelism: 8


if is_torch_available():
				import torch






def      _A				(UpperCamelCase		:      Dict      ,			UpperCamelCase		:      int      ,			UpperCamelCase		:      Optional[Any]=None )  ->Optional[int]:



			'''simple docstring'''







			if rng is None:
						lowerCamelCase__ :      List[Any]								=		random.Random()

			lowerCamelCase__ :      Tuple								=		1
			for dim in shape:
						total_dims *= dim

			lowerCamelCase__ :      str								=		[]
			for _ in range(UpperCamelCase ):
						values.append(rng.randint(0      ,			vocab_size - 1 ) )

			lowerCamelCase__ :      str								=		np.array(UpperCamelCase      ,			dtype=jnp.intaa ).reshape(UpperCamelCase )

			return output






def      _A				(UpperCamelCase		:      str      ,			UpperCamelCase		:      Dict=None )  ->List[str]:



			'''simple docstring'''







			lowerCamelCase__ :      Any								=		ids_tensor(UpperCamelCase      ,			vocab_size=2      ,			rng=UpperCamelCase )
			# make sure that at least one token is attended to for each batch
			lowerCamelCase__ :      int								=		1
			return attn_mask
@require_flax
class 				__A					:
			UpperCamelCase					:List[Any]     =			None
			UpperCamelCase					:Dict     =			()





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__ :      Dict								=		self.model_tester.prepare_config_and_inputs_for_common()

						# cut to half length & take max batch_size 3
						lowerCamelCase__ :      List[Any]								=		2
						lowerCamelCase__ :      Any								=		inputs["""input_ids"""].shape[-1] // 2
						lowerCamelCase__ :      Dict								=		inputs["""input_ids"""][:max_batch_size, :sequence_length]

						lowerCamelCase__ :      List[Any]								=		jnp.ones_like(__magic_name__				)
						lowerCamelCase__ :      Dict								=		attention_mask[:max_batch_size, :sequence_length]

						# generate max 5 tokens
						lowerCamelCase__ :      Tuple								=		input_ids.shape[-1] + 5
						if config.eos_token_id is not None and config.pad_token_id is None:
									# hack to allow generate for models such as GPT2 as is done in `generate()`
									lowerCamelCase__ :      List[Any]								=		config.eos_token_id
						return config, input_ids, attention_mask, max_length





			@is_pt_flax_cross_test
			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      List[Any]								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      Tuple								=		False
						lowerCamelCase__ :      Tuple								=		max_length
						lowerCamelCase__ :      List[Any]								=		0

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      List[Any]								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Tuple								=		model_class.__name__[4:]  # Skip the "Flax" at the beginning
									lowerCamelCase__ :      Union[str, Any]								=		getattr(__magic_name__							,    __magic_name__				)
									lowerCamelCase__ :      Dict								=		pt_model_class(__magic_name__				).eval()
									lowerCamelCase__ :      Union[str, Any]								=		load_flax_weights_in_pytorch_model(__magic_name__							,    flax_model.params				)

									lowerCamelCase__ :      str								=		flax_model.generate(__magic_name__				).sequences
									lowerCamelCase__ :      str								=		pt_model.generate(torch.tensor(__magic_name__							,    dtype=torch.long				)				)

									if flax_generation_outputs.shape[-1] > pt_generation_outputs.shape[-1]:
												lowerCamelCase__ :      Optional[Any]								=		flax_generation_outputs[:, : pt_generation_outputs.shape[-1]]

									self.assertListEqual(pt_generation_outputs.numpy().tolist()							,    flax_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Tuple								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      Dict								=		False
						lowerCamelCase__ :      str								=		max_length

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Tuple								=		model_class(__magic_name__				)

									lowerCamelCase__ :      int								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      int								=		jit(model.generate				)
									lowerCamelCase__ :      List[str]								=		jit_generate(__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Union[str, Any]								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      List[str]								=		True
						lowerCamelCase__ :      Dict								=		max_length

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      str								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Dict								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      Tuple								=		jit(model.generate				)
									lowerCamelCase__ :      List[str]								=		jit_generate(__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Dict								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      Union[str, Any]								=		False
						lowerCamelCase__ :      Dict								=		max_length
						lowerCamelCase__ :      str								=		2

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Optional[int]								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Union[str, Any]								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      Dict								=		jit(model.generate				)
									lowerCamelCase__ :      Optional[int]								=		jit_generate(__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      int								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      Dict								=		False
						lowerCamelCase__ :      List[Any]								=		max_length
						lowerCamelCase__ :      List[Any]								=		2
						lowerCamelCase__ :      List[str]								=		2

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Optional[Any]								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Union[str, Any]								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[0]							,    input_ids.shape[0] * config.num_return_sequences				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Tuple								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      Optional[int]								=		True
						lowerCamelCase__ :      str								=		max_length
						lowerCamelCase__ :      Optional[int]								=		0.8
						lowerCamelCase__ :      List[Any]								=		10
						lowerCamelCase__ :      int								=		0.3
						lowerCamelCase__ :      Union[str, Any]								=		1
						lowerCamelCase__ :      int								=		8
						lowerCamelCase__ :      Tuple								=		9

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Optional[Any]								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Any								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      Optional[int]								=		jit(model.generate				)
									lowerCamelCase__ :      List[Any]								=		jit_generate(__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      List[str]								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      str								=		max_length
						lowerCamelCase__ :      List[str]								=		1
						lowerCamelCase__ :      Optional[int]								=		8
						lowerCamelCase__ :      Union[str, Any]								=		9

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Dict								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Tuple								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      Optional[int]								=		jit(model.generate				)
									lowerCamelCase__ :      Dict								=		jit_generate(__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      int								=		self._get_input_ids_and_config()
						lowerCamelCase__ :      Tuple								=		max_length
						lowerCamelCase__ :      Optional[int]								=		2
						lowerCamelCase__ :      Union[str, Any]								=		1
						lowerCamelCase__ :      Tuple								=		8
						lowerCamelCase__ :      Tuple								=		9

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Optional[int]								=		model_class(__magic_name__				)

									lowerCamelCase__ :      List[Any]								=		model.generate(__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      List[Any]								=		jit(model.generate				)
									lowerCamelCase__ :      Union[str, Any]								=		jit_generate(__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Tuple								=		self._get_input_ids_and_config()

						# pad attention mask on the left
						lowerCamelCase__ :      Any								=		attention_mask.at[(0, 0)].set(0				)

						lowerCamelCase__ :      List[str]								=		False
						lowerCamelCase__ :      str								=		max_length

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Dict								=		model_class(__magic_name__				)

									lowerCamelCase__ :      List[str]								=		model.generate(__magic_name__							,    attention_mask=__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      Tuple								=		jit(model.generate				)
									lowerCamelCase__ :      Any								=		jit_generate(__magic_name__							,    attention_mask=__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Optional[Any]								=		self._get_input_ids_and_config()

						# pad attention mask on the left
						lowerCamelCase__ :      Optional[Any]								=		attention_mask.at[(0, 0)].set(0				)

						lowerCamelCase__ :      int								=		True
						lowerCamelCase__ :      str								=		max_length

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      int								=		model_class(__magic_name__				)

									lowerCamelCase__ :      str								=		model.generate(__magic_name__							,    attention_mask=__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      List[Any]								=		jit(model.generate				)
									lowerCamelCase__ :      List[Any]								=		jit_generate(__magic_name__							,    attention_mask=__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      Optional[Any]								=		self._get_input_ids_and_config()

						# pad attention mask on the left
						lowerCamelCase__ :      Union[str, Any]								=		attention_mask.at[(0, 0)].set(0				)

						lowerCamelCase__ :      Tuple								=		2
						lowerCamelCase__ :      List[Any]								=		max_length

						for model_class in self.all_generative_model_classes:
									lowerCamelCase__ :      Optional[Any]								=		model_class(__magic_name__				)

									lowerCamelCase__ :      Union[str, Any]								=		model.generate(__magic_name__							,    attention_mask=__magic_name__				).sequences
									self.assertEqual(generation_outputs.shape[-1]							,    __magic_name__				)

									lowerCamelCase__ :      int								=		jit(model.generate				)
									lowerCamelCase__ :      Any								=		jit_generate(__magic_name__							,    attention_mask=__magic_name__				).sequences

									self.assertListEqual(generation_outputs.tolist()							,    jit_generation_outputs.tolist()				)







@require_flax
class 				__A					( unittest.TestCase      ):





			def        _snake_case    (self				):
						lowerCamelCase__ :      Dict								=		AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-bert"""				)
						lowerCamelCase__ :      Tuple								=		FlaxAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-bert-flax-only"""				)

						lowerCamelCase__ :      Dict								=		"""Hello world"""
						lowerCamelCase__ :      Union[str, Any]								=		tokenizer(__magic_name__							,    return_tensors="""np"""				).input_ids

						# typos are quickly detected (the correct argument is `do_sample`)
						with self.assertRaisesRegex(__magic_name__							,    """do_samples"""				):
									model.generate(__magic_name__							,    do_samples=__magic_name__				)

						# arbitrary arguments that will not be used anywhere are also not accepted
						with self.assertRaisesRegex(__magic_name__							,    """foo"""				):
									lowerCamelCase__ :      Tuple								=		{"""foo""": """bar"""}
									model.generate(__magic_name__							,    **__magic_name__				)








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


_lowercase     							=						{
    '''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      _A				(UpperCamelCase		:      Any )  ->List[str]:



			'''simple docstring'''







			lowerCamelCase__ :      List[str]								=		["""layers""", """blocks"""]
			for k in ignore_keys:
						state_dict.pop(UpperCamelCase      ,			UpperCamelCase )


_lowercase     							=						{
    '''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      _A				(UpperCamelCase		:      Union[str, Any] )  ->Optional[Any]:



			'''simple docstring'''







			lowerCamelCase__ :      Union[str, Any]								=		list(s_dict.keys() )
			for key in keys:
						lowerCamelCase__ :      Dict								=		key
						for k, v in WHISPER_MAPPING.items():
									if k in key:
												lowerCamelCase__ :      Tuple								=		new_key.replace(UpperCamelCase      ,			UpperCamelCase )

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

						lowerCamelCase__ :      int								=		s_dict.pop(UpperCamelCase )
			return s_dict






def      _A				(UpperCamelCase		:      List[Any] )  ->Optional[Any]:



			'''simple docstring'''







			lowerCamelCase__							,lowerCamelCase__ :      int								=		emb.weight.shape
			lowerCamelCase__ :      Optional[int]								=		nn.Linear(UpperCamelCase      ,			UpperCamelCase      ,			bias=UpperCamelCase )
			lowerCamelCase__ :      List[str]								=		emb.weight.data
			return lin_layer






def      _A				(UpperCamelCase		:      str      ,			UpperCamelCase		:      str )  ->bytes:



			'''simple docstring'''







			os.makedirs(UpperCamelCase      ,			exist_ok=UpperCamelCase )
			lowerCamelCase__ :      Any								=		os.path.basename(UpperCamelCase )

			lowerCamelCase__ :      int								=		url.split("""/""" )[-2]
			lowerCamelCase__ :      Optional[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__ :      Dict								=		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__ :      Tuple								=		source.read(8192 )
												if not buffer:
															break

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

			lowerCamelCase__ :      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      _A				(UpperCamelCase		:      Dict      ,			UpperCamelCase		:      Any )  ->Optional[Any]:



			'''simple docstring'''







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

			lowerCamelCase__ :      List[str]								=		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[str]								=		WhisperForConditionalGeneration(UpperCamelCase )
			lowerCamelCase__							,lowerCamelCase__ :      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__ :      int								=		proj_out_weights

			model.save_pretrained(UpperCamelCase )


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

				convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)



