



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



def      __UpperCAmelCase      (    __lowerCamelCase	)							->      str:
		lowercase__   :    Optional[int]				=			ASTConfig()

		if "10-10" in model_name:
				pass
		elif "speech-commands" in model_name:
				lowercase__   :    str				=			1_28
		elif "12-12" in model_name:
				lowercase__   :    Optional[int]				=			12
				lowercase__   :    Any				=			12
		elif "14-14" in model_name:
				lowercase__   :    Any				=			14
				lowercase__   :    Optional[Any]				=			14
		elif "16-16" in model_name:
				lowercase__   :    Tuple				=			16
				lowercase__   :    int				=			16
		else:
				raise ValueError('''Model not supported'''	)

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

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

		return config



def      __UpperCAmelCase      (    __lowerCamelCase	)							->      List[str]:

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

		return name



def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      Union[str, Any]:

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

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

		return orig_state_dict



def      __UpperCAmelCase      (    __lowerCamelCase	)							->      List[Any]:
		lowercase__   :    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      (    __lowerCamelCase						,     __lowerCamelCase						,     __lowerCamelCase=False	)							->      Optional[int]:
		lowercase__   :    Any				=			get_audio_spectrogram_transformer_config(UpperCamelCase__	)

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

		# load 🤗 model
		lowercase__   :    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
		lowercase__   :    Union[str, Any]				=			-4.2_6_7_7_3_9_3 if '''speech-commands''' not in model_name else -6.8_4_5_9_7_8
		lowercase__   :    List[str]				=			4.5_6_8_9_9_7_4 if '''speech-commands''' not in model_name else 5.5_6_5_4_5_2_6
		lowercase__   :    List[Any]				=			10_24 if '''speech-commands''' not in model_name else 1_28
		lowercase__   :    Dict				=			ASTFeatureExtractor(mean=UpperCamelCase__						,     std=UpperCamelCase__						,     max_length=UpperCamelCase__	)

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

				lowercase__		,			lowercase__   :    List[str]				=			torchaudio.load(UpperCamelCase__	)
				lowercase__   :    List[str]				=			waveform.squeeze().numpy()

		lowercase__   :    Union[str, Any]				=			feature_extractor(UpperCamelCase__						,     sampling_rate=1_60_00						,     return_tensors='''pt'''	)

		# forward pass
		lowercase__   :    Tuple				=			model(**UpperCamelCase__	)
		lowercase__   :    Optional[int]				=			outputs.logits

		if model_name == "ast-finetuned-audioset-10-10-0.4593":
				lowercase__   :    Union[str, 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":
				lowercase__   :    Optional[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":
				lowercase__   :    Dict				=			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":
				lowercase__   :    Dict				=			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":
				lowercase__   :    str				=			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":
				lowercase__   :    str				=			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":
				lowercase__   :    Any				=			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":
				lowercase__   :    List[Any]				=			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)







import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow


if is_torch_available():
				import torch

				from transformers import XLMRobertaModel

@require_sentencepiece
@require_tokenizers
@require_torch
class 	A_       (unittest.TestCase			):
	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				XLMRobertaModel.from_pretrained('''xlm-roberta-base'''		)
				UpperCAmelCase   		=				torch.tensor([[0, 5_8_1, 1_0_2_6_9, 8_3, 9_9_9_4_2, 1_3_6, 6_0_7_4_2, 2_3, 7_0, 8_0_5_8_3, 1_8_2_7_6, 2]]		)
				# The dog is cute and lives in the garden house

				UpperCAmelCase   		=				torch.Size((1, 1_2, 7_6_8)		)  # batch_size, sequence_length, embedding_vector_dim
				UpperCAmelCase   		=				torch.tensor(
				    [[-0.01_01, 0.12_18, -0.08_03, 0.08_01, 0.13_27, 0.07_76, -0.12_15, 0.23_83, 0.33_38, 0.31_06, 0.03_00, 0.02_52]]		)
				#  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')
				#  xlmr.eval()
				#  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
				with torch.no_grad():
							UpperCAmelCase   		=				model(_A		)['''last_hidden_state'''].detach()
				self.assertEqual(output.shape							,					_A		)
				# compare the actual values for a slice of last dim
				self.assertTrue(torch.allclose(output[:, :, -1]							,					_A							,					atol=1E-3		)		)







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				XLMRobertaModel.from_pretrained('''xlm-roberta-large'''		)
				UpperCAmelCase   		=				torch.tensor([[0, 5_8_1, 1_0_2_6_9, 8_3, 9_9_9_4_2, 1_3_6, 6_0_7_4_2, 2_3, 7_0, 8_0_5_8_3, 1_8_2_7_6, 2]]		)
				# The dog is cute and lives in the garden house

				UpperCAmelCase   		=				torch.Size((1, 1_2, 1_0_2_4)		)  # batch_size, sequence_length, embedding_vector_dim
				UpperCAmelCase   		=				torch.tensor(
				    [[-0.06_99, -0.03_18, 0.07_05, -0.12_41, 0.09_99, -0.05_20, 0.10_04, -0.18_38, -0.47_04, 0.14_37, 0.08_21, 0.01_26]]		)
				#  xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.large')
				#  xlmr.eval()
				#  expected_output_values_last_dim = xlmr.extract_features(input_ids[0])[:, :, -1]
				with torch.no_grad():
							UpperCAmelCase   		=				model(_A		)['''last_hidden_state'''].detach()
				self.assertEqual(output.shape							,					_A		)
				# compare the actual values for a slice of last dim
				self.assertTrue(torch.allclose(output[:, :, -1]							,					_A							,					atol=1E-3		)		)



