


from dataclasses import dataclass
from typing import Optional

import numpy as np
import torch
import torch.nn as nn

from ..utils import BaseOutput, is_torch_version, randn_tensor
from .attention_processor import SpatialNorm
from .unet_ad_blocks import UNetMidBlockaD, get_down_block, get_up_block



@dataclass
class 							_UpperCamelCase (						A						):

   '''simple docstring'''







   a_				:							torch.FloatTensor



class 							_UpperCamelCase (						nn.Module						):

   '''simple docstring'''







   def __init__(  self  : int       ,  _lowerCamelCase  : str=3       ,  _lowerCamelCase  : Dict=3       ,  _lowerCamelCase  : Optional[int]=("DownEncoderBlock2D",)       ,  _lowerCamelCase  : List[str]=(6_4,)       ,  _lowerCamelCase  : List[str]=2       ,  _lowerCamelCase  : Optional[int]=3_2       ,  _lowerCamelCase  : int="silu"       ,  _lowerCamelCase  : str=True       ,  ):






         '''simple docstring'''



         super().__init__()
         __lowerCamelCase     :      List[str]       						=						layers_per_block

         __lowerCamelCase     :      Optional[int]       						=						torch.nn.Convad(
             _lowerCamelCase       ,  block_out_channels[0]       ,  kernel_size=3       ,  stride=1       ,  padding=1       ,  )

         __lowerCamelCase     :      Any       						=						None
         __lowerCamelCase     :      Optional[int]       						=						nn.ModuleList([]							)

         # down
         __lowerCamelCase     :      Dict       						=						block_out_channels[0]
         for i, down_block_type in enumerate(_lowerCamelCase							):
               __lowerCamelCase     :      Optional[Any]       						=						output_channel
               __lowerCamelCase     :      Dict       						=						block_out_channels[i]
               __lowerCamelCase     :      List[Any]       						=						i == len(_lowerCamelCase							) - 1

               __lowerCamelCase     :      Dict       						=						get_down_block(
                   _lowerCamelCase       ,  num_layers=self.layers_per_block       ,  in_channels=_lowerCamelCase       ,  out_channels=_lowerCamelCase       ,  add_downsample=not is_final_block       ,  resnet_eps=1E-6       ,  downsample_padding=0       ,  resnet_act_fn=_lowerCamelCase       ,  resnet_groups=_lowerCamelCase       ,  attention_head_dim=_lowerCamelCase       ,  temb_channels=_lowerCamelCase       ,  )
               self.down_blocks.append(_lowerCamelCase							)

         # mid
         __lowerCamelCase     :      str       						=						UNetMidBlockaD(
             in_channels=block_out_channels[-1]       ,  resnet_eps=1E-6       ,  resnet_act_fn=_lowerCamelCase       ,  output_scale_factor=1       ,  resnet_time_scale_shift="""default"""       ,  attention_head_dim=block_out_channels[-1]       ,  resnet_groups=_lowerCamelCase       ,  temb_channels=_lowerCamelCase       ,  )

         # out
         __lowerCamelCase     :      Any       						=						nn.GroupNorm(num_channels=block_out_channels[-1]       ,  num_groups=_lowerCamelCase       ,  eps=1E-6							)
         __lowerCamelCase     :      Optional[int]       						=						nn.SiLU()

         __lowerCamelCase     :      Dict       						=						2 * out_channels if double_z else out_channels
         __lowerCamelCase     :      Tuple       						=						nn.Convad(block_out_channels[-1]       ,  _lowerCamelCase       ,  3       ,  padding=1							)

         __lowerCamelCase     :      Any       						=						False


   def   _snake_case    (  self  : Optional[int]       ,  _lowerCamelCase  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						x
         __lowerCamelCase     :      int       						=						self.conv_in(_lowerCamelCase							)

         if self.training and self.gradient_checkpointing:

               def create_custom_forward(_lowerCamelCase  : Tuple							):
                     def custom_forward(*_lowerCamelCase  : Any							):
                           return module(*_lowerCamelCase							)

                     return custom_forward

               # down
               if is_torch_version(""">="""       ,  """1.11.0"""							):
                     for down_block in self.down_blocks:
                           __lowerCamelCase     :      int       						=						torch.utils.checkpoint.checkpoint(
                               create_custom_forward(_lowerCamelCase							)       ,  _lowerCamelCase       ,  use_reentrant=_lowerCamelCase							)
                     # middle
                     __lowerCamelCase     :      List[Any]       						=						torch.utils.checkpoint.checkpoint(
                         create_custom_forward(self.mid_block							)       ,  _lowerCamelCase       ,  use_reentrant=_lowerCamelCase							)
               else:
                     for down_block in self.down_blocks:
                           __lowerCamelCase     :      List[str]       						=						torch.utils.checkpoint.checkpoint(create_custom_forward(_lowerCamelCase							)       ,  _lowerCamelCase							)
                     # middle
                     __lowerCamelCase     :      str       						=						torch.utils.checkpoint.checkpoint(create_custom_forward(self.mid_block							)       ,  _lowerCamelCase							)

         else:
               # down
               for down_block in self.down_blocks:
                     __lowerCamelCase     :      List[Any]       						=						down_block(_lowerCamelCase							)

               # middle
               __lowerCamelCase     :      int       						=						self.mid_block(_lowerCamelCase							)

         # post-process
         __lowerCamelCase     :      str       						=						self.conv_norm_out(_lowerCamelCase							)
         __lowerCamelCase     :      int       						=						self.conv_act(_lowerCamelCase							)
         __lowerCamelCase     :      Dict       						=						self.conv_out(_lowerCamelCase							)

         return sample



class 							_UpperCamelCase (						nn.Module						):

   '''simple docstring'''







   def __init__(  self  : Optional[Any]       ,  _lowerCamelCase  : Optional[int]=3       ,  _lowerCamelCase  : List[str]=3       ,  _lowerCamelCase  : List[Any]=("UpDecoderBlock2D",)       ,  _lowerCamelCase  : str=(6_4,)       ,  _lowerCamelCase  : str=2       ,  _lowerCamelCase  : int=3_2       ,  _lowerCamelCase  : Union[str, Any]="silu"       ,  _lowerCamelCase  : Dict="group"       ,  ):






         '''simple docstring'''



         super().__init__()
         __lowerCamelCase     :      Optional[int]       						=						layers_per_block

         __lowerCamelCase     :      int       						=						nn.Convad(
             _lowerCamelCase       ,  block_out_channels[-1]       ,  kernel_size=3       ,  stride=1       ,  padding=1       ,  )

         __lowerCamelCase     :      Tuple       						=						None
         __lowerCamelCase     :      Optional[Any]       						=						nn.ModuleList([]							)

         __lowerCamelCase     :      Any       						=						in_channels if norm_type == """spatial""" else None

         # mid
         __lowerCamelCase     :      Any       						=						UNetMidBlockaD(
             in_channels=block_out_channels[-1]       ,  resnet_eps=1E-6       ,  resnet_act_fn=_lowerCamelCase       ,  output_scale_factor=1       ,  resnet_time_scale_shift="""default""" if norm_type == """group""" else norm_type       ,  attention_head_dim=block_out_channels[-1]       ,  resnet_groups=_lowerCamelCase       ,  temb_channels=_lowerCamelCase       ,  )

         # up
         __lowerCamelCase     :      List[Any]       						=						list(reversed(_lowerCamelCase							)							)
         __lowerCamelCase     :      Tuple       						=						reversed_block_out_channels[0]
         for i, up_block_type in enumerate(_lowerCamelCase							):
               __lowerCamelCase     :      Dict       						=						output_channel
               __lowerCamelCase     :      str       						=						reversed_block_out_channels[i]

               __lowerCamelCase     :      Tuple       						=						i == len(_lowerCamelCase							) - 1

               __lowerCamelCase     :      Tuple       						=						get_up_block(
                   _lowerCamelCase       ,  num_layers=self.layers_per_block + 1       ,  in_channels=_lowerCamelCase       ,  out_channels=_lowerCamelCase       ,  prev_output_channel=_lowerCamelCase       ,  add_upsample=not is_final_block       ,  resnet_eps=1E-6       ,  resnet_act_fn=_lowerCamelCase       ,  resnet_groups=_lowerCamelCase       ,  attention_head_dim=_lowerCamelCase       ,  temb_channels=_lowerCamelCase       ,  resnet_time_scale_shift=_lowerCamelCase       ,  )
               self.up_blocks.append(_lowerCamelCase							)
               __lowerCamelCase     :      Tuple       						=						output_channel

         # out
         if norm_type == "spatial":
               __lowerCamelCase     :      Union[str, Any]       						=						SpatialNorm(block_out_channels[0]       ,  _lowerCamelCase							)
         else:
               __lowerCamelCase     :      int       						=						nn.GroupNorm(num_channels=block_out_channels[0]       ,  num_groups=_lowerCamelCase       ,  eps=1E-6							)
         __lowerCamelCase     :      int       						=						nn.SiLU()
         __lowerCamelCase     :      Dict       						=						nn.Convad(block_out_channels[0]       ,  _lowerCamelCase       ,  3       ,  padding=1							)

         __lowerCamelCase     :      int       						=						False


   def   _snake_case    (  self  : List[str]       ,  _lowerCamelCase  : Union[str, Any]       ,  _lowerCamelCase  : Tuple=None							):






         '''simple docstring'''



         __lowerCamelCase     :      List[Any]       						=						z
         __lowerCamelCase     :      Union[str, Any]       						=						self.conv_in(_lowerCamelCase							)

         __lowerCamelCase     :      Dict       						=						next(iter(self.up_blocks.parameters()							)							).dtype
         if self.training and self.gradient_checkpointing:

               def create_custom_forward(_lowerCamelCase  : int							):
                     def custom_forward(*_lowerCamelCase  : Any							):
                           return module(*_lowerCamelCase							)

                     return custom_forward

               if is_torch_version(""">="""       ,  """1.11.0"""							):
                     # middle
                     __lowerCamelCase     :      Dict       						=						torch.utils.checkpoint.checkpoint(
                         create_custom_forward(self.mid_block							)       ,  _lowerCamelCase       ,  _lowerCamelCase       ,  use_reentrant=_lowerCamelCase							)
                     __lowerCamelCase     :      List[str]       						=						sample.to(_lowerCamelCase							)

                     # up
                     for up_block in self.up_blocks:
                           __lowerCamelCase     :      List[str]       						=						torch.utils.checkpoint.checkpoint(
                               create_custom_forward(_lowerCamelCase							)       ,  _lowerCamelCase       ,  _lowerCamelCase       ,  use_reentrant=_lowerCamelCase							)
               else:
                     # middle
                     __lowerCamelCase     :      int       						=						torch.utils.checkpoint.checkpoint(
                         create_custom_forward(self.mid_block							)       ,  _lowerCamelCase       ,  _lowerCamelCase							)
                     __lowerCamelCase     :      Optional[Any]       						=						sample.to(_lowerCamelCase							)

                     # up
                     for up_block in self.up_blocks:
                           __lowerCamelCase     :      Optional[int]       						=						torch.utils.checkpoint.checkpoint(create_custom_forward(_lowerCamelCase							)       ,  _lowerCamelCase       ,  _lowerCamelCase							)
         else:
               # middle
               __lowerCamelCase     :      Dict       						=						self.mid_block(_lowerCamelCase       ,  _lowerCamelCase							)
               __lowerCamelCase     :      Optional[int]       						=						sample.to(_lowerCamelCase							)

               # up
               for up_block in self.up_blocks:
                     __lowerCamelCase     :      Any       						=						up_block(_lowerCamelCase       ,  _lowerCamelCase							)

        # post-process
         if latent_embeds is None:
               __lowerCamelCase     :      Any       						=						self.conv_norm_out(_lowerCamelCase							)
         else:
               __lowerCamelCase     :      Any       						=						self.conv_norm_out(_lowerCamelCase       ,  _lowerCamelCase							)
         __lowerCamelCase     :      List[str]       						=						self.conv_act(_lowerCamelCase							)
         __lowerCamelCase     :      str       						=						self.conv_out(_lowerCamelCase							)

         return sample



class 							_UpperCamelCase (						nn.Module						):

   '''simple docstring'''







   def __init__(  self  : List[str]       ,  _lowerCamelCase  : int       ,  _lowerCamelCase  : Union[str, Any]       ,  _lowerCamelCase  : Optional[Any]       ,  _lowerCamelCase  : Optional[int]=None       ,  _lowerCamelCase  : int="random"       ,  _lowerCamelCase  : List[Any]=False       ,  _lowerCamelCase  : Union[str, Any]=True							):






         '''simple docstring'''



         super().__init__()
         __lowerCamelCase     :      str       						=						n_e
         __lowerCamelCase     :      Optional[Any]       						=						vq_embed_dim
         __lowerCamelCase     :      Tuple       						=						beta
         __lowerCamelCase     :      int       						=						legacy

         __lowerCamelCase     :      Tuple       						=						nn.Embedding(self.n_e       ,  self.vq_embed_dim							)
         self.embedding.weight.data.uniform_(-1.0 / self.n_e       ,  1.0 / self.n_e							)

         __lowerCamelCase     :      Optional[Any]       						=						remap
         if self.remap is not None:
               self.register_buffer("""used"""       ,  torch.tensor(np.load(self.remap							)							)							)
               __lowerCamelCase     :      Union[str, Any]       						=						self.used.shape[0]
               __lowerCamelCase     :      Tuple       						=						unknown_index  # "random" or "extra" or integer
               if self.unknown_index == "extra":
                     __lowerCamelCase     :      int       						=						self.re_embed
                     __lowerCamelCase     :      Tuple       						=						self.re_embed + 1
               print(
                   F"""Remapping {self.n_e} indices to {self.re_embed} indices. """
                   F"""Using {self.unknown_index} for unknown indices."""							)
         else:
               __lowerCamelCase     :      Dict       						=						n_e

         __lowerCamelCase     :      Union[str, Any]       						=						sane_index_shape

   def   _snake_case    (  self  : Tuple       ,  _lowerCamelCase  : int							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[int]       						=						inds.shape
         assert len(_lowerCamelCase							) > 1
         __lowerCamelCase     :      Optional[Any]       						=						inds.reshape(ishape[0]       ,  -1							)
         __lowerCamelCase     :      List[Any]       						=						self.used.to(_lowerCamelCase							)
         __lowerCamelCase     :      Union[str, Any]       						=						(inds[:, :, None] == used[None, None, ...]).long()
         __lowerCamelCase     :      Tuple       						=						match.argmax(-1							)
         __lowerCamelCase     :      Union[str, Any]       						=						match.sum(2							) < 1
         if self.unknown_index == "random":
               __lowerCamelCase     :      List[Any]       						=						torch.randint(0       ,  self.re_embed       ,  size=new[unknown].shape							).to(device=new.device							)
         else:
               __lowerCamelCase     :      Any       						=						self.unknown_index
         return new.reshape(_lowerCamelCase							)

   def   _snake_case    (  self  : List[Any]       ,  _lowerCamelCase  : Union[str, Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      str       						=						inds.shape
         assert len(_lowerCamelCase							) > 1
         __lowerCamelCase     :      str       						=						inds.reshape(ishape[0]       ,  -1							)
         __lowerCamelCase     :      List[str]       						=						self.used.to(_lowerCamelCase							)
         if self.re_embed > self.used.shape[0]:  # extra token
               __lowerCamelCase     :      Dict       						=						0  # simply set to zero
         __lowerCamelCase     :      Union[str, Any]       						=						torch.gather(used[None, :][inds.shape[0] * [0], :]       ,  1       ,  _lowerCamelCase							)
         return back.reshape(_lowerCamelCase							)

   def   _snake_case    (  self  : Any       ,  _lowerCamelCase  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						z.permute(0       ,  2       ,  3       ,  1							).contiguous()
         __lowerCamelCase     :      Union[str, Any]       						=						z.view(-1       ,  self.vq_embed_dim							)

         # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
         __lowerCamelCase     :      Union[str, Any]       						=						torch.argmin(torch.cdist(_lowerCamelCase       ,  self.embedding.weight							)       ,  dim=1							)

         __lowerCamelCase     :      List[str]       						=						self.embedding(_lowerCamelCase							).view(z.shape							)
         __lowerCamelCase     :      Optional[Any]       						=						None
         __lowerCamelCase     :      Any       						=						None

         # compute loss for embedding
         if not self.legacy:
               __lowerCamelCase     :      List[str]       						=						self.beta * torch.mean((z_q.detach() - z) ** 2							) + torch.mean((z_q - z.detach()) ** 2							)
         else:
               __lowerCamelCase     :      Tuple       						=						torch.mean((z_q.detach() - z) ** 2							) + self.beta * torch.mean((z_q - z.detach()) ** 2							)

         # preserve gradients
         __lowerCamelCase     :      str       						=						z + (z_q - z).detach()

         # reshape back to match original input shape
         __lowerCamelCase     :      Dict       						=						z_q.permute(0       ,  3       ,  1       ,  2							).contiguous()

         if self.remap is not None:
               __lowerCamelCase     :      Optional[Any]       						=						min_encoding_indices.reshape(z.shape[0]       ,  -1							)  # add batch axis
               __lowerCamelCase     :      List[str]       						=						self.remap_to_used(_lowerCamelCase							)
               __lowerCamelCase     :      int       						=						min_encoding_indices.reshape(-1       ,  1							)  # flatten

         if self.sane_index_shape:
               __lowerCamelCase     :      Dict       						=						min_encoding_indices.reshape(z_q.shape[0]       ,  z_q.shape[2]       ,  z_q.shape[3]							)

         return z_q, loss, (perplexity, min_encodings, min_encoding_indices)


   def   _snake_case    (  self  : List[Any]       ,  _lowerCamelCase  : Optional[int]       ,  _lowerCamelCase  : Optional[Any]							):






         '''simple docstring'''



         if self.remap is not None:
               __lowerCamelCase     :      List[str]       						=						indices.reshape(shape[0]       ,  -1							)  # add batch axis
               __lowerCamelCase     :      str       						=						self.unmap_to_all(_lowerCamelCase							)
               __lowerCamelCase     :      List[str]       						=						indices.reshape(-1							)  # flatten again

         # get quantized latent vectors
         __lowerCamelCase     :      int       						=						self.embedding(_lowerCamelCase							)

         if shape is not None:
               __lowerCamelCase     :      Dict       						=						z_q.view(_lowerCamelCase							)
               # reshape back to match original input shape
               __lowerCamelCase     :      str       						=						z_q.permute(0       ,  3       ,  1       ,  2							).contiguous()

         return z_q



class 							_UpperCamelCase (						A						):

   '''simple docstring'''







   def __init__(  self  : Optional[Any]       ,  _lowerCamelCase  : str       ,  _lowerCamelCase  : Optional[int]=False							):






         '''simple docstring'''



         __lowerCamelCase     :      Tuple       						=						parameters
         __lowerCamelCase						, __lowerCamelCase     :      Union[str, Any]       						=						torch.chunk(_lowerCamelCase       ,  2       ,  dim=1							)
         __lowerCamelCase     :      Dict       						=						torch.clamp(self.logvar       ,  -30.0       ,  20.0							)
         __lowerCamelCase     :      Dict       						=						deterministic
         __lowerCamelCase     :      List[Any]       						=						torch.exp(0.5 * self.logvar							)
         __lowerCamelCase     :      Optional[int]       						=						torch.exp(self.logvar							)
         if self.deterministic:
               __lowerCamelCase     :      Optional[Any]       						=						torch.zeros_like(
                   self.mean       ,  device=self.parameters.device       ,  dtype=self.parameters.dtype							)

   def   _snake_case    (  self  : List[Any]       ,  _lowerCamelCase  : Optional[torch.Generator] = None							):






         '''simple docstring'''



         __lowerCamelCase     :      str       						=						randn_tensor(
             self.mean.shape       ,  generator=_lowerCamelCase       ,  device=self.parameters.device       ,  dtype=self.parameters.dtype							)
         __lowerCamelCase     :      Union[str, Any]       						=						self.mean + self.std * sample
         return x

   def   _snake_case    (  self  : List[str]       ,  _lowerCamelCase  : List[str]=None							):






         '''simple docstring'''



         if self.deterministic:
               return torch.Tensor([0.0]							)
         else:
               if other is None:
                     return 0.5 * torch.sum(torch.pow(self.mean       ,  2							) + self.var - 1.0 - self.logvar       ,  dim=[1, 2, 3]							)
               else:
                     return 0.5 * torch.sum(
                         torch.pow(self.mean - other.mean       ,  2							) / other.var
                         + self.var / other.var
                         - 1.0
                         - self.logvar
                         + other.logvar       ,  dim=[1, 2, 3]       ,  )

   def   _snake_case    (  self  : str       ,  _lowerCamelCase  : Optional[int]       ,  _lowerCamelCase  : Optional[Any]=[1, 2, 3]							):






         '''simple docstring'''



         if self.deterministic:
               return torch.Tensor([0.0]							)
         __lowerCamelCase     :      Any       						=						np.log(2.0 * np.pi							)
         return 0.5 * torch.sum(logtwopi + self.logvar + torch.pow(sample - self.mean       ,  2							) / self.var       ,  dim=_lowerCamelCase							)


   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         return self.mean







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    :						Tuple     =							{
    '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      :			Dict      ):
      """simple docstring"""




      __lowerCamelCase     :      int       						=						["""layers""", """blocks"""]
      for k in ignore_keys:
            state_dict.pop(UpperCAmelCase						,	UpperCAmelCase      )


__UpperCamelCase    :						str     =							{
    '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      :			Dict      ):
      """simple docstring"""




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

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

            __lowerCamelCase     :      Dict       						=						s_dict.pop(UpperCAmelCase      )
      return s_dict





def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[int]      ):
      """simple docstring"""




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





def   _UpperCAmelCase       (     UpperCAmelCase      :			str						,	UpperCAmelCase      :			str      ):
      """simple docstring"""




      os.makedirs(UpperCAmelCase						,	exist_ok=UpperCAmelCase      )
      __lowerCamelCase     :      Any       						=						os.path.basename(UpperCAmelCase      )

      __lowerCamelCase     :      int       						=						url.split("""/"""      )[-2]
      __lowerCamelCase     :      str       						=						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     :      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=80						,	unit="""iB"""						,	unit_scale=UpperCAmelCase						,	unit_divisor=1_024      ) as loop:
                  while True:
                        __lowerCamelCase     :      Union[str, Any]       						=						source.read(8_192      )
                        if not buffer:
                              break

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

      __lowerCamelCase     :      List[str]       						=						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      :			Optional[int]      ):
      """simple docstring"""




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

      __lowerCamelCase     :      Any       						=						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     :      Tuple       						=						make_linear_from_emb(model.model.decoder.embed_tokens      )
      else:
            __lowerCamelCase     :      Tuple       						=						proj_out_weights

      model.save_pretrained(UpperCAmelCase      )


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

    convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)



