'''simple docstring'''





import argparse
import json
from pathlib import Path

import torch
import torchaudio
from datasets import load_dataset
from huggingface_hub import hf_hub_download

from transformers import ASTConfig, ASTFeatureExtractor, ASTForAudioClassification
from transformers.utils import logging


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_:     Optional[int]  =logging.get_logger(__name__)





def 	lowerCAmelCase_				(					snake_case_       : Any			)    ->      int:


     '''simple docstring'''




     UpperCAmelCase_           =   ASTConfig()

     if "10-10" in model_name:
          pass
     elif "speech-commands" in model_name:
          UpperCAmelCase_           =   1_28
     elif "12-12" in model_name:
          UpperCAmelCase_           =   12
          UpperCAmelCase_           =   12
     elif "14-14" in model_name:
          UpperCAmelCase_           =   14
          UpperCAmelCase_           =   14
     elif "16-16" in model_name:
          UpperCAmelCase_           =   16
          UpperCAmelCase_           =   16
     else:
          raise ValueError("Model not supported"			)

     UpperCAmelCase_           =   "huggingface/label-files"
     if "speech-commands" in model_name:
          UpperCAmelCase_           =   35
          UpperCAmelCase_           =   "speech-commands-v2-id2label.json"
     else:
          UpperCAmelCase_           =   5_27
          UpperCAmelCase_           =   "audioset-id2label.json"

     UpperCAmelCase_           =   json.load(open(hf_hub_download(snake_case_					,    snake_case_					,    repo_type="dataset"			)					,    "r"			)			)
     UpperCAmelCase_           =   {int(snake_case_			): v for k, v in idalabel.items()}
     UpperCAmelCase_           =   idalabel
     UpperCAmelCase_           =   {v: k for k, v in idalabel.items()}

     return config





def 	lowerCAmelCase_				(					snake_case_       : List[str]			)    ->      Any:


     '''simple docstring'''




     if "module.v" in name:
          UpperCAmelCase_           =   name.replace("module.v"					,    "audio_spectrogram_transformer"			)
     if "cls_token" in name:
          UpperCAmelCase_           =   name.replace("cls_token"					,    "embeddings.cls_token"			)
     if "dist_token" in name:
          UpperCAmelCase_           =   name.replace("dist_token"					,    "embeddings.distillation_token"			)
     if "pos_embed" in name:
          UpperCAmelCase_           =   name.replace("pos_embed"					,    "embeddings.position_embeddings"			)
     if "patch_embed.proj" in name:
          UpperCAmelCase_           =   name.replace("patch_embed.proj"					,    "embeddings.patch_embeddings.projection"			)
     # transformer blocks
     if "blocks" in name:
          UpperCAmelCase_           =   name.replace("blocks"					,    "encoder.layer"			)
     if "attn.proj" in name:
          UpperCAmelCase_           =   name.replace("attn.proj"					,    "attention.output.dense"			)
     if "attn" in name:
          UpperCAmelCase_           =   name.replace("attn"					,    "attention.self"			)
     if "norm1" in name:
          UpperCAmelCase_           =   name.replace("norm1"					,    "layernorm_before"			)
     if "norm2" in name:
          UpperCAmelCase_           =   name.replace("norm2"					,    "layernorm_after"			)
     if "mlp.fc1" in name:
          UpperCAmelCase_           =   name.replace("mlp.fc1"					,    "intermediate.dense"			)
     if "mlp.fc2" in name:
          UpperCAmelCase_           =   name.replace("mlp.fc2"					,    "output.dense"			)
     # final layernorm
     if "audio_spectrogram_transformer.norm" in name:
          UpperCAmelCase_           =   name.replace("audio_spectrogram_transformer.norm"					,    "audio_spectrogram_transformer.layernorm"			)
     # classifier head
     if "module.mlp_head.0" in name:
          UpperCAmelCase_           =   name.replace("module.mlp_head.0"					,    "classifier.layernorm"			)
     if "module.mlp_head.1" in name:
          UpperCAmelCase_           =   name.replace("module.mlp_head.1"					,    "classifier.dense"			)

     return name





def 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : Optional[Any]			)    ->      Union[str, Any]:


     '''simple docstring'''




     for key in orig_state_dict.copy().keys():
          UpperCAmelCase_           =   orig_state_dict.pop(snake_case_			)

          if "qkv" in key:
               UpperCAmelCase_           =   key.split("."			)
               UpperCAmelCase_           =   int(key_split[3]			)
               UpperCAmelCase_           =   config.hidden_size
               if "weight" in key:
                    UpperCAmelCase_           =   val[:dim, :]
                    UpperCAmelCase_           =   val[dim : dim * 2, :]
                    UpperCAmelCase_           =   val[-dim:, :]
               else:
                    UpperCAmelCase_           =   val[:dim]
                    UpperCAmelCase_           =   val[dim : dim * 2]
                    UpperCAmelCase_           =   val[-dim:]
          else:
               UpperCAmelCase_           =   val

     return orig_state_dict





def 	lowerCAmelCase_				(					snake_case_       : Any			)    ->      str:


     '''simple docstring'''




     UpperCAmelCase_           =   [
         "module.v.head.weight",
         "module.v.head.bias",
         "module.v.head_dist.weight",
         "module.v.head_dist.bias",
     ]
     for k in ignore_keys:
          state_dict.pop(snake_case_					,    snake_case_			)





@torch.no_grad()
def 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : Any					,    snake_case_       : Optional[int]=False			)    ->      List[Any]:


     '''simple docstring'''




     UpperCAmelCase_           =   get_audio_spectrogram_transformer_config(snake_case_			)

     UpperCAmelCase_           =   {
         "ast-finetuned-audioset-10-10-0.4593": (
             "https://www.dropbox.com/s/ca0b1v2nlxzyeb4/audioset_10_10_0.4593.pth?dl=1"
         ),
         "ast-finetuned-audioset-10-10-0.450": (
             "https://www.dropbox.com/s/1tv0hovue1bxupk/audioset_10_10_0.4495.pth?dl=1"
         ),
         "ast-finetuned-audioset-10-10-0.448": (
             "https://www.dropbox.com/s/6u5sikl4b9wo4u5/audioset_10_10_0.4483.pth?dl=1"
         ),
         "ast-finetuned-audioset-10-10-0.448-v2": (
             "https://www.dropbox.com/s/kt6i0v9fvfm1mbq/audioset_10_10_0.4475.pth?dl=1"
         ),
         "ast-finetuned-audioset-12-12-0.447": (
             "https://www.dropbox.com/s/snfhx3tizr4nuc8/audioset_12_12_0.4467.pth?dl=1"
         ),
         "ast-finetuned-audioset-14-14-0.443": (
             "https://www.dropbox.com/s/z18s6pemtnxm4k7/audioset_14_14_0.4431.pth?dl=1"
         ),
         "ast-finetuned-audioset-16-16-0.442": (
             "https://www.dropbox.com/s/mdsa4t1xmcimia6/audioset_16_16_0.4422.pth?dl=1"
         ),
         "ast-finetuned-speech-commands-v2": (
             "https://www.dropbox.com/s/q0tbqpwv44pquwy/speechcommands_10_10_0.9812.pth?dl=1"
         ),
     }

     # load original state_dict
     UpperCAmelCase_           =   model_name_to_url[model_name]
     UpperCAmelCase_           =   torch.hub.load_state_dict_from_url(snake_case_					,    map_location="cpu"			)
     # remove some keys
     remove_keys(snake_case_			)
     # rename some keys
     UpperCAmelCase_           =   convert_state_dict(snake_case_					,    snake_case_			)

     # load 🤗 model
     UpperCAmelCase_           =   ASTForAudioClassification(snake_case_			)
     model.eval()

     model.load_state_dict(snake_case_			)

     # verify outputs on dummy input
     # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
     UpperCAmelCase_           =   -4.267_7393 if "speech-commands" not in model_name else -6.84_5978
     UpperCAmelCase_           =   4.568_9974 if "speech-commands" not in model_name else 5.565_4526
     UpperCAmelCase_           =   10_24 if "speech-commands" not in model_name else 1_28
     UpperCAmelCase_           =   ASTFeatureExtractor(mean=snake_case_					,    std=snake_case_					,    max_length=snake_case_			)

     if "speech-commands" in model_name:
          UpperCAmelCase_           =   load_dataset("speech_commands"					,    "v0.02"					,    split="validation"			)
          UpperCAmelCase_           =   dataset[0]["audio"]["array"]
     else:
          UpperCAmelCase_           =   hf_hub_download(
              repo_id="nielsr/audio-spectogram-transformer-checkpoint"					,    filename="sample_audio.flac"					,    repo_type="dataset"					,    )

          UpperCAmelCase_    , UpperCAmelCase_           =   torchaudio.load(snake_case_			)
          UpperCAmelCase_           =   waveform.squeeze().numpy()

     UpperCAmelCase_           =   feature_extractor(snake_case_					,    sampling_rate=1_60_00					,    return_tensors="pt"			)

     # forward pass
     UpperCAmelCase_           =   model(**snake_case_			)
     UpperCAmelCase_           =   outputs.logits

     if model_name == "ast-finetuned-audioset-10-10-0.4593":
          UpperCAmelCase_           =   torch.tensor([-0.8760, -7.0042, -8.6602]			)
     elif model_name == "ast-finetuned-audioset-10-10-0.450":
          UpperCAmelCase_           =   torch.tensor([-1.1986, -7.0903, -8.2718]			)
     elif model_name == "ast-finetuned-audioset-10-10-0.448":
          UpperCAmelCase_           =   torch.tensor([-2.6128, -8.0080, -9.4344]			)
     elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
          UpperCAmelCase_           =   torch.tensor([-1.5080, -7.4534, -8.8917]			)
     elif model_name == "ast-finetuned-audioset-12-12-0.447":
          UpperCAmelCase_           =   torch.tensor([-0.5050, -6.5833, -8.0843]			)
     elif model_name == "ast-finetuned-audioset-14-14-0.443":
          UpperCAmelCase_           =   torch.tensor([-0.3826, -7.0336, -8.2413]			)
     elif model_name == "ast-finetuned-audioset-16-16-0.442":
          UpperCAmelCase_           =   torch.tensor([-1.2113, -6.9101, -8.3470]			)
     elif model_name == "ast-finetuned-speech-commands-v2":
          UpperCAmelCase_           =   torch.tensor([6.1589, -8.0566, -8.7984]			)
     else:
          raise ValueError("Unknown model name"			)
     if not torch.allclose(logits[0, :3]					,    snake_case_					,    atol=1E-4			):
          raise ValueError("Logits don't match"			)
     print("Looks ok!"			)

     if pytorch_dump_folder_path is not None:
          Path(snake_case_			).mkdir(exist_ok=snake_case_			)
          print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""			)
          model.save_pretrained(snake_case_			)
          print(f"""Saving feature extractor to {pytorch_dump_folder_path}"""			)
          feature_extractor.save_pretrained(snake_case_			)

     if push_to_hub:
          print("Pushing model and feature extractor to the hub..."			)
          model.push_to_hub(f"""MIT/{model_name}"""			)
          feature_extractor.push_to_hub(f"""MIT/{model_name}"""			)


if __name__ == "__main__":
    SCREAMING_SNAKE_CASE_:     Tuple  =argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--model_name',
        default='ast-finetuned-audioset-10-10-0.4593',
        type=str,
        help='Name of the Audio Spectrogram Transformer model you\'d like to convert.',
    )
    parser.add_argument(
        '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
    )
    parser.add_argument(
        '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
    )

    SCREAMING_SNAKE_CASE_:     List[Any]  =parser.parse_args()
    convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





'''simple docstring'''





from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_:     Dict  =logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_:     Tuple  ={}




class        __A      ( UpperCamelCase__	):
    a__       :						int          =  """llama"""
    a__       :						Any          =  ["""past_key_values"""]



    def __init__(self    :    List[str]   ,			__a    :    List[str]=32000   ,			__a    :    Tuple=4096   ,			__a    :    List[Any]=11008   ,			__a    :    Dict=32   ,			__a    :    Tuple=32   ,			__a    :    Any=None   ,			__a    :    Any="silu"   ,			__a    :    List[Any]=2048   ,			__a    :    List[Any]=0.02   ,			__a    :    str=1E-6   ,			__a    :    Optional[Any]=True   ,			__a    :    Union[str, Any]=0   ,			__a    :    Any=1   ,			__a    :    Dict=2   ,			__a    :    Dict=1   ,			__a    :    str=False   ,			__a    :    str=None   ,			**__a    :    Optional[Any]   ,			):
         UpperCAmelCase_           =   vocab_size
         UpperCAmelCase_           =   max_position_embeddings
         UpperCAmelCase_           =   hidden_size
         UpperCAmelCase_           =   intermediate_size
         UpperCAmelCase_           =   num_hidden_layers
         UpperCAmelCase_           =   num_attention_heads

         # for backward compatibility
         if num_key_value_heads is None:
              UpperCAmelCase_           =   num_attention_heads

         UpperCAmelCase_           =   num_key_value_heads
         UpperCAmelCase_           =   hidden_act
         UpperCAmelCase_           =   initializer_range
         UpperCAmelCase_           =   rms_norm_eps
         UpperCAmelCase_           =   pretraining_tp
         UpperCAmelCase_           =   use_cache
         UpperCAmelCase_           =   rope_scaling
         self._rope_scaling_validation()

         super().__init__(
             pad_token_id=__a   ,			bos_token_id=__a   ,			eos_token_id=__a   ,			tie_word_embeddings=__a   ,			**__a   ,			)






    def 					_lowercase						(self    :    List[str] ):
         if self.rope_scaling is None:
              return

         if not isinstance(self.rope_scaling   ,			__a ) or len(self.rope_scaling ) != 2:
              raise ValueError(
                  "`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, "
                  f"""got {self.rope_scaling}""" )
         UpperCAmelCase_           =   self.rope_scaling.get("type"   ,			__a )
         UpperCAmelCase_           =   self.rope_scaling.get("factor"   ,			__a )
         if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
              raise ValueError(
                  f"""`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}""" )
         if rope_scaling_factor is None or not isinstance(__a   ,			__a ) or rope_scaling_factor <= 1.0:
              raise ValueError(f"""`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}""" )




