






import argparse
import hashlib
import os
import urllib
import warnings

import torch
from torch import nn
from tqdm import tqdm

from transformers import WhisperConfig, WhisperForConditionalGeneration


__a:     Union[str, Any]   					=					{
    """tiny.en""": """https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt""",
    """tiny""": """https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt""",
    """base.en""": """https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt""",
    """base""": """https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt""",
    """small.en""": """https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt""",
    """small""": """https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt""",
    """medium.en""": """https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt""",
    """medium""": """https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt""",
    """large""": """https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt""",
    """large-v2""": """https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt""",
}




def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						int:
       _UpperCAmelCase							=    ['layers', 'blocks']
       for k in ignore_keys:
              state_dict.pop(_A   ,      _A )


__a:     Any   					=					{
    """blocks""": """layers""",
    """mlp.0""": """fc1""",
    """mlp.2""": """fc2""",
    """mlp_ln""": """final_layer_norm""",
    """.attn.query""": """.self_attn.q_proj""",
    """.attn.key""": """.self_attn.k_proj""",
    """.attn.value""": """.self_attn.v_proj""",
    """.attn_ln""": """.self_attn_layer_norm""",
    """.attn.out""": """.self_attn.out_proj""",
    """.cross_attn.query""": """.encoder_attn.q_proj""",
    """.cross_attn.key""": """.encoder_attn.k_proj""",
    """.cross_attn.value""": """.encoder_attn.v_proj""",
    """.cross_attn_ln""": """.encoder_attn_layer_norm""",
    """.cross_attn.out""": """.encoder_attn.out_proj""",
    """decoder.ln.""": """decoder.layer_norm.""",
    """encoder.ln.""": """encoder.layer_norm.""",
    """token_embedding""": """embed_tokens""",
    """encoder.positional_embedding""": """encoder.embed_positions.weight""",
    """decoder.positional_embedding""": """decoder.embed_positions.weight""",
    """ln_post""": """layer_norm""",
}




def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						Optional[int]:
       _UpperCAmelCase							=    list(s_dict.keys() )
       for key in keys:
              _UpperCAmelCase							=    key
              for k, v in WHISPER_MAPPING.items():
                     if k in key:
                            _UpperCAmelCase							=    new_key.replace(_A   ,      _A )

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

              _UpperCAmelCase							=    s_dict.pop(_A )
       return s_dict




def       _SCREAMING_SNAKE_CASE (							__snake_case )				->						str:
       _UpperCAmelCase							=    emb.weight.shape
       _UpperCAmelCase							=    nn.Linear(_A   ,      _A   ,      bias=_A )
       _UpperCAmelCase							=    emb.weight.data
       return lin_layer




def       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						str:
       os.makedirs(_A   ,      exist_ok=_A )
       _UpperCAmelCase							=    os.path.basename(_A )

       _UpperCAmelCase							=    url.split("""/""" )[-2]
       _UpperCAmelCase							=    os.path.join(_A   ,      _A )

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

       if os.path.isfile(_A ):
              _UpperCAmelCase							=    open(_A   ,      """rb""" ).read()
              if hashlib.shaaaa(_A ).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(_A ) as source, open(_A   ,      """wb""" ) as output:
              with tqdm(
                  total=int(source.info().get("""Content-Length""" ) )   ,      ncols=8_0   ,      unit="""iB"""   ,      unit_scale=_A   ,      unit_divisor=1_0_2_4 ) as loop:
                     while True:
                            _UpperCAmelCase							=    source.read(8_1_9_2 )
                            if not buffer:
                                   break

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

       _UpperCAmelCase							=    open(_A   ,      """rb""" ).read()
       if hashlib.shaaaa(_A ).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       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case )				->						List[Any]:







       if ".pt" not in checkpoint_path:
              _UpperCAmelCase							=    _download(_MODELS[checkpoint_path] )
       else:
              _UpperCAmelCase							=    torch.load(_A   ,      map_location="""cpu""" )
       _UpperCAmelCase							=    original_checkpoint['dims']
       _UpperCAmelCase							=    original_checkpoint['model_state_dict']
       _UpperCAmelCase							=    state_dict['decoder.token_embedding.weight']
       remove_ignore_keys_(_A )
       rename_keys(_A )
       _UpperCAmelCase							=    True
       _UpperCAmelCase							=    state_dict['decoder.layers.0.fc1.weight'].shape[0]

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

       model.save_pretrained(_A )


if __name__ == "__main__":
  __a:     Tuple   					=					argparse.ArgumentParser()
  # # Required parameters
  parser.add_argument('''--checkpoint_path''', type=str, help='''Patht to the downloaded checkpoints''')
  parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
  __a:     Union[str, Any]   					=					parser.parse_args()

  convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)



'''simple docstring'''







import os

from bleurt import score  # From: git+https://github.com/google-research/bleurt.git

import datasets


lowerCAmelCase     :  Optional[int]											=    datasets.logging.get_logger(__name__)


lowerCAmelCase     :  List[str]											=    """\
@inproceedings{bleurt,
  title={BLEURT: Learning Robust Metrics for Text Generation},
  author={Thibault Sellam and Dipanjan Das and Ankur P. Parikh},
  booktitle={ACL},
  year={2020},
  url={https://arxiv.org/abs/2004.04696}
}
"""

lowerCAmelCase     :  List[Any]											=    """\
BLEURT a learnt evaluation metric for Natural Language Generation. It is built using multiple phases of transfer learning starting from a pretrained BERT model (Devlin et al. 2018)
and then employing another pre-training phrase using synthetic data. Finally it is trained on WMT human annotations. You may run BLEURT out-of-the-box or fine-tune
it for your specific application (the latter is expected to perform better).

See the project's README at https://github.com/google-research/bleurt#readme for more information.
"""

lowerCAmelCase     :  str											=    """
BLEURT score.

Args:
    `predictions` (list of str): prediction/candidate sentences
    `references` (list of str): reference sentences
    `checkpoint` BLEURT checkpoint. Will default to BLEURT-tiny if None.

Returns:
    'scores': List of scores.
Examples:

    >>> predictions = [\"hello there\", \"general kenobi\"]
    >>> references = [\"hello there\", \"general kenobi\"]
    >>> bleurt = datasets.load_metric(\"bleurt\")
    >>> results = bleurt.compute(predictions=predictions, references=references)
    >>> print([round(v, 2) for v in results[\"scores\"]])
    [1.03, 1.04]
"""

lowerCAmelCase     :  Optional[Any]											=    {
    """bleurt-tiny-128""": """https://storage.googleapis.com/bleurt-oss/bleurt-tiny-128.zip""",
    """bleurt-tiny-512""": """https://storage.googleapis.com/bleurt-oss/bleurt-tiny-512.zip""",
    """bleurt-base-128""": """https://storage.googleapis.com/bleurt-oss/bleurt-base-128.zip""",
    """bleurt-base-512""": """https://storage.googleapis.com/bleurt-oss/bleurt-base-512.zip""",
    """bleurt-large-128""": """https://storage.googleapis.com/bleurt-oss/bleurt-large-128.zip""",
    """bleurt-large-512""": """https://storage.googleapis.com/bleurt-oss/bleurt-large-512.zip""",
    """BLEURT-20-D3""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D3.zip""",
    """BLEURT-20-D6""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D6.zip""",
    """BLEURT-20-D12""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D12.zip""",
    """BLEURT-20""": """https://storage.googleapis.com/bleurt-oss-21/BLEURT-20.zip""",
}
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,       _KWARGS_DESCRIPTION						)
class 						UpperCamelCase__       (			datasets.Metric						):



     """simple docstring"""






     def a						(			self ):

            '''simple docstring'''

            return datasets.MetricInfo(
                description=_DESCRIPTION   ,						citation=_CITATION   ,						homepage='https://github.com/google-research/bleurt'   ,						inputs_description=_KWARGS_DESCRIPTION   ,						features=datasets.Features(
                    {
                        'predictions': datasets.Value('string'   ,						id='sequence' ),
                        'references': datasets.Value('string'   ,						id='sequence' ),
                    } )   ,						codebase_urls=['https://github.com/google-research/bleurt']   ,						reference_urls=['https://github.com/google-research/bleurt', 'https://arxiv.org/abs/2004.04696']   ,						)







     def a						(			self   ,						snake_case__ ):

            '''simple docstring'''

            if self.config_name == "default":
                   logger.warning(
                       'Using default BLEURT-Base checkpoint for sequence maximum length 128. '
                       'You can use a bigger model for better results with e.g.: datasets.load_metric(\'bleurt\', \'bleurt-large-512\').' )
                   _lowerCAmelCase     :				Tuple       =							'bleurt-base-128'

            if self.config_name.lower() in CHECKPOINT_URLS:
                   _lowerCAmelCase     :				int       =							self.config_name.lower()

            elif self.config_name.upper() in CHECKPOINT_URLS:
                   _lowerCAmelCase     :				str       =							self.config_name.upper()

            else:
                   raise KeyError(
                       F'{self.config_name} model not found. You should supply the name of a model checkpoint for bleurt in {CHECKPOINT_URLS.keys()}' )

            # download the model checkpoint specified by self.config_name and set up the scorer
            _lowerCAmelCase     :				Optional[Any]       =							dl_manager.download_and_extract(CHECKPOINT_URLS[checkpoint_name] )
            _lowerCAmelCase     :				str       =							score.BleurtScorer(os.path.join(snake_case__   ,						snake_case__ ) )







     def a						(			self   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Tuple       =							self.scorer.score(references=snake_case__   ,						candidates=snake_case__ )
            return {"scores": scores}

