






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()
lowerCamelCase__       		=  logging.get_logger(__name__)






def 	UpperCamelCase	(							snake_case__  : int	):




     '''simple docstring'''






     __snake_case      :Dict 							=    ASTConfig()

     if "10-10" in model_name:
          pass
     elif "speech-commands" in model_name:
          __snake_case      :int 							=    128
     elif "12-12" in model_name:
          __snake_case      :int 							=    12
          __snake_case      :Optional[Any] 							=    12
     elif "14-14" in model_name:
          __snake_case      :List[str] 							=    14
          __snake_case      :str 							=    14
     elif "16-16" in model_name:
          __snake_case      :List[Any] 							=    16
          __snake_case      :Dict 							=    16
     else:
          raise ValueError("""Model not supported"""	)

     __snake_case      :Optional[int] 							=    '''huggingface/label-files'''
     if "speech-commands" in model_name:
          __snake_case      :List[str] 							=    35
          __snake_case      :int 							=    '''speech-commands-v2-id2label.json'''
     else:
          __snake_case      :List[Any] 							=    527
          __snake_case      :List[Any] 							=    '''audioset-id2label.json'''

     __snake_case      :List[Any] 							=    json.load(open(hf_hub_download(UpperCamelCase__						,UpperCamelCase__						,repo_type="""dataset"""	)						,"""r"""	)	)
     __snake_case      :Optional[int] 							=    {int(UpperCamelCase__	): v for k, v in idalabel.items()}
     __snake_case      :Union[str, Any] 							=    idalabel
     __snake_case      :str 							=    {v: k for k, v in idalabel.items()}

     return config






def 	UpperCamelCase	(							snake_case__  : Dict	):




     '''simple docstring'''






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

     return name






def 	UpperCamelCase	(							snake_case__  : Optional[int]						,snake_case__  : Optional[Any]	):




     '''simple docstring'''






     for key in orig_state_dict.copy().keys():
          __snake_case      :Any 							=    orig_state_dict.pop(UpperCamelCase__	)

          if "qkv" in key:
               __snake_case      :Tuple 							=    key.split("""."""	)
               __snake_case      :str 							=    int(key_split[3]	)
               __snake_case      :Union[str, Any] 							=    config.hidden_size
               if "weight" in key:
                    __snake_case      :Optional[int] 							=    val[:dim, :]
                    __snake_case      :List[Any] 							=    val[dim : dim * 2, :]
                    __snake_case      :List[str] 							=    val[-dim:, :]
               else:
                    __snake_case      :str 							=    val[:dim]
                    __snake_case      :Optional[int] 							=    val[dim : dim * 2]
                    __snake_case      :Any 							=    val[-dim:]
          else:
               __snake_case      :List[str] 							=    val

     return orig_state_dict






def 	UpperCamelCase	(							snake_case__  : Union[str, Any]	):




     '''simple docstring'''






     __snake_case      :Union[str, Any] 							=    [
         '''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(UpperCamelCase__						,UpperCamelCase__	)






@torch.no_grad()
def 	UpperCamelCase	(							snake_case__  : int						,snake_case__  : Optional[Any]						,snake_case__  : List[str]=False	):




     '''simple docstring'''






     __snake_case      :List[str] 							=    get_audio_spectrogram_transformer_config(UpperCamelCase__	)

     __snake_case      :Union[str, Any] 							=    {
         '''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
     __snake_case      :Optional[Any] 							=    model_name_to_url[model_name]
     __snake_case      :str 							=    torch.hub.load_state_dict_from_url(UpperCamelCase__						,map_location="""cpu"""	)
     # remove some keys
     remove_keys(UpperCamelCase__	)
     # rename some keys
     __snake_case      :List[str] 							=    convert_state_dict(UpperCamelCase__						,UpperCamelCase__	)

     # load 🤗 model
     __snake_case      :Optional[int] 							=    ASTForAudioClassification(UpperCamelCase__	)
     model.eval()

     model.load_state_dict(UpperCamelCase__	)

     # verify outputs on dummy input
     # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
     __snake_case      :Any 							=    -4.2_6_7_7_3_9_3 if '''speech-commands''' not in model_name else -6.8_4_5_9_7_8
     __snake_case      :List[Any] 							=    4.5_6_8_9_9_7_4 if '''speech-commands''' not in model_name else 5.5_6_5_4_5_2_6
     __snake_case      :str 							=    1024 if '''speech-commands''' not in model_name else 128
     __snake_case      :int 							=    ASTFeatureExtractor(mean=UpperCamelCase__						,std=UpperCamelCase__						,max_length=UpperCamelCase__	)

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

          __snake_case      :Union[str, Any] 							=    torchaudio.load(UpperCamelCase__	)
          __snake_case      :str 							=    waveform.squeeze().numpy()

     __snake_case      :Any 							=    feature_extractor(UpperCamelCase__						,sampling_rate=1_6000						,return_tensors="""pt"""	)

     # forward pass
     __snake_case      :Optional[Any] 							=    model(**UpperCamelCase__	)
     __snake_case      :str 							=    outputs.logits

     if model_name == "ast-finetuned-audioset-10-10-0.4593":
          __snake_case      :Any 							=    torch.tensor([-0.8_7_6_0, -7.0_0_4_2, -8.6_6_0_2]	)
     elif model_name == "ast-finetuned-audioset-10-10-0.450":
          __snake_case      :Union[str, Any] 							=    torch.tensor([-1.1_9_8_6, -7.0_9_0_3, -8.2_7_1_8]	)
     elif model_name == "ast-finetuned-audioset-10-10-0.448":
          __snake_case      :str 							=    torch.tensor([-2.6_1_2_8, -8.0_0_8_0, -9.4_3_4_4]	)
     elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
          __snake_case      :List[str] 							=    torch.tensor([-1.5_0_8_0, -7.4_5_3_4, -8.8_9_1_7]	)
     elif model_name == "ast-finetuned-audioset-12-12-0.447":
          __snake_case      :Optional[Any] 							=    torch.tensor([-0.5_0_5_0, -6.5_8_3_3, -8.0_8_4_3]	)
     elif model_name == "ast-finetuned-audioset-14-14-0.443":
          __snake_case      :Tuple 							=    torch.tensor([-0.3_8_2_6, -7.0_3_3_6, -8.2_4_1_3]	)
     elif model_name == "ast-finetuned-audioset-16-16-0.442":
          __snake_case      :str 							=    torch.tensor([-1.2_1_1_3, -6.9_1_0_1, -8.3_4_7_0]	)
     elif model_name == "ast-finetuned-speech-commands-v2":
          __snake_case      :int 							=    torch.tensor([6.1_5_8_9, -8.0_5_6_6, -8.7_9_8_4]	)
     else:
          raise ValueError("""Unknown model name"""	)
     if not torch.allclose(logits[0, :3]						,UpperCamelCase__						,atol=1e-4	):
          raise ValueError("""Logits don\'t match"""	)
     print("""Looks ok!"""	)

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

     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__":
     lowerCamelCase__       		=  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."""
     )

     lowerCamelCase__       		=  parser.parse_args()
     convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









def 		lowerCAmelCase  (	UpperCamelCase__   :   int       ,			UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float					)      ->    float:

						"""simple docstring"""





						return round(float(moles / volume					) * nfactor					)






def 		lowerCAmelCase  (	UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float					)      ->    float:

						"""simple docstring"""





						return round(float((moles * 0.08_21 * temperature) / (volume)					)					)






def 		lowerCAmelCase  (	UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float					)      ->    float:

						"""simple docstring"""





						return round(float((moles * 0.08_21 * temperature) / (pressure)					)					)






def 		lowerCAmelCase  (	UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float       ,			UpperCamelCase__   :   float					)      ->    float:

						"""simple docstring"""





						return round(float((pressure * volume) / (0.08_21 * moles)					)					)


if __name__ == "__main__":
							import doctest

							doctest.testmod()



