





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


__lowerCamelCase			:	List[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 						A_							(	_lowerCAmelCase	)		->					Tuple:
 UpperCamelCase      :   int			      =  ["layers", "blocks"]
 for k in ignore_keys:
  state_dict.pop(_lowerCAmelCase				,  _lowerCAmelCase	)


__lowerCamelCase			:	List[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 						A_							(	_lowerCAmelCase	)		->					int:
 UpperCamelCase      :   List[Any]			      =  list(s_dict.keys()	)
 for key in keys:
  UpperCamelCase      :   Optional[int]			      =  key
  for k, v in WHISPER_MAPPING.items():
   if k in key:
    UpperCamelCase      :   str			      =  new_key.replace(_lowerCAmelCase				,  _lowerCAmelCase	)

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

  UpperCamelCase      :   str			      =  s_dict.pop(_lowerCAmelCase	)
 return s_dict



def 						A_							(	_lowerCAmelCase	)		->					Dict:
 UpperCamelCase      ,       UpperCamelCase      :   List[str]			      =  emb.weight.shape
 UpperCamelCase      :   Dict			      =  nn.Linear(_lowerCAmelCase				,  _lowerCAmelCase				,  bias=_lowerCAmelCase	)
 UpperCamelCase      :   List[Any]			      =  emb.weight.data
 return lin_layer



def 						A_							(	_lowerCAmelCase				,  _lowerCAmelCase	)		->					bytes:
 os.makedirs(_lowerCAmelCase				,  exist_ok=_lowerCAmelCase	)
 UpperCamelCase      :   List[str]			      =  os.path.basename(_lowerCAmelCase	)

 UpperCamelCase      :   int			      =  url.split("/"	)[-2]
 UpperCamelCase      :   List[str]			      =  os.path.join(_lowerCAmelCase				,  _lowerCAmelCase	)

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

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

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

 UpperCamelCase      :   Optional[int]			      =  open(_lowerCAmelCase				,  "rb"	).read()
 if hashlib.shaaaa(_lowerCAmelCase	).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_							(	_lowerCAmelCase				,  _lowerCAmelCase	)		->					Optional[int]:
 if ".pt" not in checkpoint_path:
  UpperCamelCase      :   Any			      =  _download(_MODELS[checkpoint_path]	)
 else:
  UpperCamelCase      :   Tuple			      =  torch.load(_lowerCAmelCase				,  map_location="cpu"	)
 UpperCamelCase      :   Any			      =  original_checkpoint["dims"]
 UpperCamelCase      :   Optional[Any]			      =  original_checkpoint["model_state_dict"]
 UpperCamelCase      :   Any			      =  state_dict["decoder.token_embedding.weight"]
 remove_ignore_keys_(_lowerCAmelCase	)
 rename_keys(_lowerCAmelCase	)
 UpperCamelCase      :   Tuple			      =  True
 UpperCamelCase      :   Optional[int]			      =  state_dict["decoder.layers.0.fc1.weight"].shape[0]

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

 model.save_pretrained(_lowerCAmelCase	)


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

    convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)







from random import shuffle

import tensorflow as tf
from numpy import array



def 						A_							(	_lowerCAmelCase				,  _lowerCAmelCase	)		->					Optional[Any]:
 UpperCamelCase      :   List[Any]			      =  int(_lowerCAmelCase	)
 assert noofclusters < len(_lowerCAmelCase	)

 # Find out the dimensionality
 UpperCamelCase      :   str			      =  len(vectors[0]	)

 # Will help select random centroids from among the available vectors
 UpperCamelCase      :   List[str]			      =  list(range(len(_lowerCAmelCase	)	)	)
 shuffle(_lowerCAmelCase	)

 # GRAPH OF COMPUTATION
 # We initialize a new graph and set it as the default during each run
 # of this algorithm. This ensures that as this function is called
 # multiple times, the default graph doesn't keep getting crowded with
 # unused ops and Variables from previous function calls.

 UpperCamelCase      :   Any			      =  tf.Graph()

 with graph.as_default():
  # SESSION OF COMPUTATION

  UpperCamelCase      :   Union[str, Any]			      =  tf.Session()

  ##CONSTRUCTING THE ELEMENTS OF COMPUTATION

  ##First lets ensure we have a Variable vector for each centroid,
  ##initialized to one of the vectors from the available data points
  UpperCamelCase      :   Optional[int]			      =  [
      tf.Variable(vectors[vector_indices[i]]	) for i in range(_lowerCAmelCase	)
  ]
  ##These nodes will assign the centroid Variables the appropriate
  ##values
  UpperCamelCase      :   Tuple			      =  tf.placeholder("float64"				,  [dim]	)
  UpperCamelCase      :   str			      =  []
  for centroid in centroids:
   cent_assigns.append(tf.assign(_lowerCAmelCase				,  _lowerCAmelCase	)	)

  ##Variables for cluster assignments of individual vectors(initialized
  ##to 0 at first)
  UpperCamelCase      :   List[str]			      =  [tf.Variable(0	) for i in range(len(_lowerCAmelCase	)	)]
  ##These nodes will assign an assignment Variable the appropriate
  ##value
  UpperCamelCase      :   Any			      =  tf.placeholder("int32"	)
  UpperCamelCase      :   Optional[int]			      =  []
  for assignment in assignments:
   cluster_assigns.append(tf.assign(_lowerCAmelCase				,  _lowerCAmelCase	)	)

  ##Now lets construct the node that will compute the mean
  # The placeholder for the input
  UpperCamelCase      :   Tuple			      =  tf.placeholder("float"				,  [None, dim]	)
  # The Node/op takes the input and computes a mean along the 0th
  # dimension, i.e. the list of input vectors
  UpperCamelCase      :   List[str]			      =  tf.reduce_mean(_lowerCAmelCase				,  0	)

  ##Node for computing Euclidean distances
  # Placeholders for input
  UpperCamelCase      :   Optional[int]			      =  tf.placeholder("float"				,  [dim]	)
  UpperCamelCase      :   Any			      =  tf.placeholder("float"				,  [dim]	)
  UpperCamelCase      :   List[str]			      =  tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(_lowerCAmelCase				,  _lowerCAmelCase	)				,  2	)	)	)

  ##This node will figure out which cluster to assign a vector to,
  ##based on Euclidean distances of the vector from the centroids.
  # Placeholder for input
  UpperCamelCase      :   Tuple			      =  tf.placeholder("float"				,  [noofclusters]	)
  UpperCamelCase      :   str			      =  tf.argmin(_lowerCAmelCase				,  0	)

  ##INITIALIZING STATE VARIABLES

  ##This will help initialization of all Variables defined with respect
  ##to the graph. The Variable-initializer should be defined after
  ##all the Variables have been constructed, so that each of them
  ##will be included in the initialization.
  UpperCamelCase      :   Optional[Any]			      =  tf.initialize_all_variables()

  # Initialize all variables
  sess.run(_lowerCAmelCase	)

  ##CLUSTERING ITERATIONS

  # Now perform the Expectation-Maximization steps of K-Means clustering
  # iterations. To keep things simple, we will only do a set number of
  # iterations, instead of using a Stopping Criterion.
  UpperCamelCase      :   Any			      =  100
  for _ in range(_lowerCAmelCase	):
   ##EXPECTATION STEP
   ##Based on the centroid locations till last iteration, compute
   ##the _expected_ centroid assignments.
   # Iterate over each vector
   for vector_n in range(len(_lowerCAmelCase	)	):
    UpperCamelCase      :   Dict			      =  vectors[vector_n]
    # Compute Euclidean distance between this vector and each
    # centroid. Remember that this list cannot be named
    #'centroid_distances', since that is the input to the
    # cluster assignment node.
    UpperCamelCase      :   Optional[Any]			      =  [
        sess.run(_lowerCAmelCase				,  feed_dict={va: vect, va: sess.run(_lowerCAmelCase	)}	)
        for centroid in centroids
    ]
    # Now use the cluster assignment node, with the distances
    # as the input
    UpperCamelCase      :   Tuple			      =  sess.run(
        _lowerCAmelCase				,  feed_dict={centroid_distances: distances}	)
    # Now assign the value to the appropriate state variable
    sess.run(
        cluster_assigns[vector_n]				,  feed_dict={assignment_value: assignment}	)

   ##MAXIMIZATION STEP
   # Based on the expected state computed from the Expectation Step,
   # compute the locations of the centroids so as to maximize the
   # overall objective of minimizing within-cluster Sum-of-Squares
   for cluster_n in range(_lowerCAmelCase	):
    # Collect all the vectors assigned to this cluster
    UpperCamelCase      :   str			      =  [
        vectors[i]
        for i in range(len(_lowerCAmelCase	)	)
        if sess.run(assignments[i]	) == cluster_n
    ]
    # Compute new centroid location
    UpperCamelCase      :   Optional[int]			      =  sess.run(
        _lowerCAmelCase				,  feed_dict={mean_input: array(_lowerCAmelCase	)}	)
    # Assign value to appropriate variable
    sess.run(
        cent_assigns[cluster_n]				,  feed_dict={centroid_value: new_location}	)

        # Return centroids and assignments
  UpperCamelCase      :   Union[str, Any]			      =  sess.run(_lowerCAmelCase	)
  UpperCamelCase      :   Tuple			      =  sess.run(_lowerCAmelCase	)
  return centroids, assignments
