



from typing import List, Optional, Union

import torch
from transformers import (
    XLMRobertaTokenizer,
)

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDIMScheduler, DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .text_encoder import MultilingualCLIP


_lowercase     							=						logging.get_logger(__name__)  # pylint: disable=invalid-name

_lowercase     							=						'''
    Examples:
        ```py
        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline
        >>> import torch

        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained("kandinsky-community/Kandinsky-2-1-prior")
        >>> pipe_prior.to("cuda")

        >>> prompt = "red cat, 4k photo"
        >>> out = pipe_prior(prompt)
        >>> image_emb = out.image_embeds
        >>> negative_image_emb = out.negative_image_embeds

        >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1")
        >>> pipe.to("cuda")

        >>> image = pipe(
        ...     prompt,
        ...     image_embeds=image_emb,
        ...     negative_image_embeds=negative_image_emb,
        ...     height=768,
        ...     width=768,
        ...     num_inference_steps=100,
        ... ).images

        >>> image[0].save("cat.png")
        ```
'''






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



			'''simple docstring'''







			lowerCamelCase__ :      Optional[Any]								=		h // scale_factor**2
			if h % scale_factor**2 != 0:
						new_h += 1
			lowerCamelCase__ :      Union[str, Any]								=		w // scale_factor**2
			if w % scale_factor**2 != 0:
						new_w += 1
			return new_h * scale_factor, new_w * scale_factor
class 				__A					( A_      ):





			def __init__(self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    ):
						super().__init__()

						self.register_modules(
						    text_encoder=__magic_name__							,    tokenizer=__magic_name__							,    unet=__magic_name__							,    scheduler=__magic_name__							,    movq=__magic_name__							,    )
						lowerCamelCase__ :      int								=		2 ** (len(self.movq.config.block_out_channels				) - 1)





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__				):
						if latents is None:
									lowerCamelCase__ :      Tuple								=		randn_tensor(__magic_name__							,    generator=__magic_name__							,    device=__magic_name__							,    dtype=__magic_name__				)
						else:
									if latents.shape != shape:
												raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}"				)
									lowerCamelCase__ :      Dict								=		latents.to(__magic_name__				)

						lowerCamelCase__ :      Optional[Any]								=		latents * scheduler.init_noise_sigma
						return latents





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__=None							,    ):
						lowerCamelCase__ :      Optional[Any]								=		len(__magic_name__				) if isinstance(__magic_name__							,    __magic_name__				) else 1
						# get prompt text embeddings
						lowerCamelCase__ :      Optional[Any]								=		self.tokenizer(
						    __magic_name__							,    padding="""max_length"""							,    truncation=__magic_name__							,    max_length=77							,    return_attention_mask=__magic_name__							,    add_special_tokens=__magic_name__							,    return_tensors="""pt"""							,    )

						lowerCamelCase__ :      Any								=		text_inputs.input_ids
						lowerCamelCase__ :      Optional[Any]								=		self.tokenizer(__magic_name__							,    padding="""longest"""							,    return_tensors="""pt"""				).input_ids

						if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(__magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      Union[str, Any]								=		self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]				)
									logger.warning(
									    """The following part of your input was truncated because CLIP can only handle sequences up to"""
									    f" {self.tokenizer.model_max_length} tokens: {removed_text}"				)

						lowerCamelCase__ :      List[str]								=		text_input_ids.to(__magic_name__				)
						lowerCamelCase__ :      Tuple								=		text_inputs.attention_mask.to(__magic_name__				)

						lowerCamelCase__ :      str								=		self.text_encoder(
						    input_ids=__magic_name__							,    attention_mask=__magic_name__				)

						lowerCamelCase__ :      int								=		prompt_embeds.repeat_interleave(__magic_name__							,    dim=0				)
						lowerCamelCase__ :      Dict								=		text_encoder_hidden_states.repeat_interleave(__magic_name__							,    dim=0				)
						lowerCamelCase__ :      Any								=		text_mask.repeat_interleave(__magic_name__							,    dim=0				)

						if do_classifier_free_guidance:
									lowerCamelCase__ :      List[str]
									if negative_prompt is None:
												lowerCamelCase__ :      Any								=		[""""""] * batch_size
									elif type(__magic_name__				) is not type(__magic_name__				):
												raise TypeError(
												    f"`negative_prompt` should be the same type to `prompt`, but got {type(__magic_name__				)} !="
												    f" {type(__magic_name__				)}."				)
									elif isinstance(__magic_name__							,    __magic_name__				):
												lowerCamelCase__ :      Optional[Any]								=		[negative_prompt]
									elif batch_size != len(__magic_name__				):
												raise ValueError(
												    f"`negative_prompt`: {negative_prompt} has batch size {len(__magic_name__				)}, but `prompt`:"
												    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
												    """ the batch size of `prompt`."""				)
									else:
												lowerCamelCase__ :      Any								=		negative_prompt

									lowerCamelCase__ :      Dict								=		self.tokenizer(
									    __magic_name__							,    padding="""max_length"""							,    max_length=77							,    truncation=__magic_name__							,    return_attention_mask=__magic_name__							,    add_special_tokens=__magic_name__							,    return_tensors="""pt"""							,    )
									lowerCamelCase__ :      Optional[Any]								=		uncond_input.input_ids.to(__magic_name__				)
									lowerCamelCase__ :      Optional[int]								=		uncond_input.attention_mask.to(__magic_name__				)

									lowerCamelCase__ :      Dict								=		self.text_encoder(
									    input_ids=__magic_name__							,    attention_mask=__magic_name__				)

									# duplicate unconditional embeddings for each generation per prompt, using mps friendly method

									lowerCamelCase__ :      str								=		negative_prompt_embeds.shape[1]
									lowerCamelCase__ :      Union[str, Any]								=		negative_prompt_embeds.repeat(1							,    __magic_name__				)
									lowerCamelCase__ :      Any								=		negative_prompt_embeds.view(batch_size * num_images_per_prompt							,    __magic_name__				)

									lowerCamelCase__ :      Optional[int]								=		uncond_text_encoder_hidden_states.shape[1]
									lowerCamelCase__ :      Optional[int]								=		uncond_text_encoder_hidden_states.repeat(1							,    __magic_name__							,    1				)
									lowerCamelCase__ :      Optional[int]								=		uncond_text_encoder_hidden_states.view(
									    batch_size * num_images_per_prompt							,    __magic_name__							,    -1				)
									lowerCamelCase__ :      Optional[int]								=		uncond_text_mask.repeat_interleave(__magic_name__							,    dim=0				)

									# done duplicates

									# For classifier free guidance, we need to do two forward passes.
									# Here we concatenate the unconditional and text embeddings into a single batch
									# to avoid doing two forward passes
									lowerCamelCase__ :      List[Any]								=		torch.cat([negative_prompt_embeds, prompt_embeds]				)
									lowerCamelCase__ :      List[str]								=		torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]				)

									lowerCamelCase__ :      List[str]								=		torch.cat([uncond_text_mask, text_mask]				)

						return prompt_embeds, text_encoder_hidden_states, text_mask





			def        _snake_case    (self							,    __magic_name__=0				):
						if is_accelerate_available():
									from accelerate import cpu_offload
						else:
									raise ImportError("""Please install accelerate via `pip install accelerate`"""				)

						lowerCamelCase__ :      Optional[Any]								=		torch.device(f"cuda:{gpu_id}"				)

						lowerCamelCase__ :      int								=		[
						    self.unet,
						    self.text_encoder,
						    self.movq,
						]
						for cpu_offloaded_model in models:
									if cpu_offloaded_model is not None:
												cpu_offload(__magic_name__							,    __magic_name__				)





			def        _snake_case    (self							,    __magic_name__=0				):
						if is_accelerate_available() and is_accelerate_version(""">="""							,    """0.17.0.dev0"""				):
									from accelerate import cpu_offload_with_hook
						else:
									raise ImportError("""`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher."""				)

						lowerCamelCase__ :      int								=		torch.device(f"cuda:{gpu_id}"				)

						if self.device.type != "cpu":
									self.to("""cpu"""							,    silence_dtype_warnings=__magic_name__				)
									torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

						lowerCamelCase__ :      Tuple								=		None
						for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]:
									lowerCamelCase__ :      Any								=		cpu_offload_with_hook(__magic_name__							,    __magic_name__							,    prev_module_hook=__magic_name__				)

						if self.safety_checker is not None:
									lowerCamelCase__ :      Optional[int]								=		cpu_offload_with_hook(self.safety_checker							,    __magic_name__							,    prev_module_hook=__magic_name__				)

						# We'll offload the last model manually.
						lowerCamelCase__ :      Dict								=		hook





			@property
			# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
			def        _snake_case    (self				):
						if not hasattr(self.unet							,    """_hf_hook"""				):
									return self.device
						for module in self.unet.modules():
									if (
									    hasattr(__magic_name__							,    """_hf_hook"""				)
									    and hasattr(module._hf_hook							,    """execution_device"""				)
									    and module._hf_hook.execution_device is not None
									):
												return torch.device(module._hf_hook.execution_device				)
						return self.device





			@torch.no_grad()
			@replace_example_docstring(__magic_name__				)
			def __call__(self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__ = None							,    __magic_name__ = 512							,    __magic_name__ = 512							,    __magic_name__ = 100							,    __magic_name__ = 4.0							,    __magic_name__ = 1							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = "pil"							,    __magic_name__ = True							,    ):

						if isinstance(__magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      int								=		1
						elif isinstance(__magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      Optional[int]								=		len(__magic_name__				)
						else:
									raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(__magic_name__				)}"				)

						lowerCamelCase__ :      str								=		self._execution_device

						lowerCamelCase__ :      Optional[int]								=		batch_size * num_images_per_prompt
						lowerCamelCase__ :      Union[str, Any]								=		guidance_scale > 1.0

						lowerCamelCase__ :      Union[str, Any]								=		self._encode_prompt(
						    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__				)

						if isinstance(__magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      Tuple								=		torch.cat(__magic_name__							,    dim=0				)
						if isinstance(__magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      Any								=		torch.cat(__magic_name__							,    dim=0				)

						if do_classifier_free_guidance:
									lowerCamelCase__ :      Union[str, Any]								=		image_embeds.repeat_interleave(__magic_name__							,    dim=0				)
									lowerCamelCase__ :      Optional[Any]								=		negative_image_embeds.repeat_interleave(__magic_name__							,    dim=0				)

						lowerCamelCase__ :      Dict								=		torch.cat([negative_image_embeds, image_embeds]							,    dim=0				).to(
						    dtype=prompt_embeds.dtype							,    device=__magic_name__				)

						self.scheduler.set_timesteps(__magic_name__							,    device=__magic_name__				)
						lowerCamelCase__ :      Dict								=		self.scheduler.timesteps

						lowerCamelCase__ :      Union[str, Any]								=		self.unet.config.in_channels

						lowerCamelCase__ :      Union[str, Any]								=		get_new_h_w(__magic_name__							,    __magic_name__							,    self.movq_scale_factor				)

						# create initial latent
						lowerCamelCase__ :      Tuple								=		self.prepare_latents(
						    (batch_size, num_channels_latents, height, width)							,    text_encoder_hidden_states.dtype							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    self.scheduler							,    )

						for i, t in enumerate(self.progress_bar(__magic_name__				)				):
									# expand the latents if we are doing classifier free guidance
									lowerCamelCase__ :      Dict								=		torch.cat([latents] * 2				) if do_classifier_free_guidance else latents

									lowerCamelCase__ :      Union[str, Any]								=		{"""text_embeds""": prompt_embeds, """image_embeds""": image_embeds}
									lowerCamelCase__ :      Union[str, Any]								=		self.unet(
									    sample=__magic_name__							,    timestep=__magic_name__							,    encoder_hidden_states=__magic_name__							,    added_cond_kwargs=__magic_name__							,    return_dict=__magic_name__							,    )[0]

									if do_classifier_free_guidance:
												lowerCamelCase__ :      Union[str, Any]								=		noise_pred.split(latents.shape[1]							,    dim=1				)
												lowerCamelCase__ :      str								=		noise_pred.chunk(2				)
												lowerCamelCase__ :      Union[str, Any]								=		variance_pred.chunk(2				)
												lowerCamelCase__ :      Optional[int]								=		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
												lowerCamelCase__ :      int								=		torch.cat([noise_pred, variance_pred_text]							,    dim=1				)

									if not (
									    hasattr(self.scheduler.config							,    """variance_type"""				)
									    and self.scheduler.config.variance_type in ["learned", "learned_range"]
									):
												lowerCamelCase__ :      Tuple								=		noise_pred.split(latents.shape[1]							,    dim=1				)

									# compute the previous noisy sample x_t -> x_t-1
									lowerCamelCase__ :      Dict								=		self.scheduler.step(
									    __magic_name__							,    __magic_name__							,    __magic_name__							,    generator=__magic_name__							,    ).prev_sample
						# post-processing
						lowerCamelCase__ :      List[str]								=		self.movq.decode(__magic_name__							,    force_not_quantize=__magic_name__				)["""sample"""]

						if output_type not in ["pt", "np", "pil"]:
									raise ValueError(f"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"				)

						if output_type in ["np", "pil"]:
									lowerCamelCase__ :      Optional[int]								=		image * 0.5 + 0.5
									lowerCamelCase__ :      Any								=		image.clamp(0							,    1				)
									lowerCamelCase__ :      List[Any]								=		image.cpu().permute(0							,    2							,    3							,    1				).float().numpy()

						if output_type == "pil":
									lowerCamelCase__ :      Any								=		self.numpy_to_pil(__magic_name__				)

						if not return_dict:
									return (image,)

						return ImagePipelineOutput(images=__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)



