





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


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	snake_case_						:	int      =		ASTConfig()

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

	snake_case_						:	Tuple      =		'huggingface/label-files'
	if "speech-commands" in model_name:
		snake_case_						:	Dict      =		35
		snake_case_						:	List[Any]      =		'speech-commands-v2-id2label.json'
	else:
		snake_case_						:	Union[str, Any]      =		5_27
		snake_case_						:	Optional[Any]      =		'audioset-id2label.json'

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

	return config


def 							SCREAMING_SNAKE_CASE__  (			__a      ):







	if "module.v" in name:
		snake_case_						:	Optional[Any]      =		name.replace('module.v'      ,       'audio_spectrogram_transformer'      )
	if "cls_token" in name:
		snake_case_						:	Dict      =		name.replace('cls_token'      ,       'embeddings.cls_token'      )
	if "dist_token" in name:
		snake_case_						:	List[Any]      =		name.replace('dist_token'      ,       'embeddings.distillation_token'      )
	if "pos_embed" in name:
		snake_case_						:	Dict      =		name.replace('pos_embed'      ,       'embeddings.position_embeddings'      )
	if "patch_embed.proj" in name:
		snake_case_						:	Tuple      =		name.replace('patch_embed.proj'      ,       'embeddings.patch_embeddings.projection'      )
	# transformer blocks
	if "blocks" in name:
		snake_case_						:	Optional[int]      =		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_						:	Optional[Any]      =		name.replace('attn'      ,       'attention.self'      )
	if "norm1" in name:
		snake_case_						:	Optional[int]      =		name.replace('norm1'      ,       'layernorm_before'      )
	if "norm2" in name:
		snake_case_						:	str      =		name.replace('norm2'      ,       'layernorm_after'      )
	if "mlp.fc1" in name:
		snake_case_						:	Tuple      =		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_						:	List[Any]      =		name.replace('audio_spectrogram_transformer.norm'      ,       'audio_spectrogram_transformer.layernorm'      )
	# classifier head
	if "module.mlp_head.0" in name:
		snake_case_						:	List[Any]      =		name.replace('module.mlp_head.0'      ,       'classifier.layernorm'      )
	if "module.mlp_head.1" in name:
		snake_case_						:	Optional[int]      =		name.replace('module.mlp_head.1'      ,       'classifier.dense'      )

	return name


def 							SCREAMING_SNAKE_CASE__  (			__a      ,       __a      ):







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

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

	return orig_state_dict


def 							SCREAMING_SNAKE_CASE__  (			__a      ):
	snake_case_						:	str      =		[
	    '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(__a      ,       __a      )


@torch.no_grad()
def 							SCREAMING_SNAKE_CASE__  (			__a      ,       __a      ,       __a=False      ):
	snake_case_						:	List[str]      =		get_audio_spectrogram_transformer_config(__a      )

	snake_case_						:	str      =		{
	    '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_						:	Dict      =		model_name_to_url[model_name]
	snake_case_						:	List[str]      =		torch.hub.load_state_dict_from_url(__a      ,       map_location='cpu'      )
	# remove some keys
	remove_keys(__a      )
	# rename some keys
	snake_case_						:	Dict      =		convert_state_dict(__a      ,       __a      )

	# load 🤗 model
	snake_case_						:	str      =		ASTForAudioClassification(__a      )
	model.eval()

	model.load_state_dict(__a      )

	# verify outputs on dummy input
	# source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
	snake_case_						:	Union[str, Any]      =		-4.2677393 if 'speech-commands' not in model_name else -6.845978
	snake_case_						:	int      =		4.5689974 if 'speech-commands' not in model_name else 5.5654526
	snake_case_						:	List[Any]      =		10_24 if 'speech-commands' not in model_name else 1_28
	snake_case_						:	str      =		ASTFeatureExtractor(mean=__a      ,       std=__a      ,       max_length=__a      )

	if "speech-commands" in model_name:
		snake_case_						:	Optional[Any]      =		load_dataset('speech_commands'      ,       'v0.02'      ,       split='validation'      )
		snake_case_						:	List[Any]      =		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_  ,snake_case_						:	List[Any]      =		torchaudio.load(__a      )
		snake_case_						:	str      =		waveform.squeeze().numpy()

	snake_case_						:	Optional[Any]      =		feature_extractor(__a      ,       sampling_rate=1_60_00      ,       return_tensors='pt'      )

	# forward pass
	snake_case_						:	List[Any]      =		model(**__a      )
	snake_case_						:	str      =		outputs.logits

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

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

	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							=						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							=						parser.parse_args()
						convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







from dataclasses import dataclass, field
from typing import Optional

from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser




@dataclass
class     snake_case__							:
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_       :							str							 =					field(
				    metadata={"""help""": """The output directory where the model will be written."""}    ,       )
				SCREAMING_SNAKE_CASE_       :							str							 =					field(
				    metadata={
				        """help""": (
				            """The encoder model checkpoint for weights initialization."""
				            """Don't set if you want to train an encoder model from scratch."""
				        )
				    }    ,       )
				SCREAMING_SNAKE_CASE_       :							str							 =					field(
				    metadata={
				        """help""": (
				            """The decoder model checkpoint for weights initialization."""
				            """Don't set if you want to train a decoder model from scratch."""
				        )
				    }    ,       )
				SCREAMING_SNAKE_CASE_       :							Optional[str]							 =					field(
				    default=_UpperCamelCase    ,       metadata={"""help""": """Pretrained encoder config name or path if not the same as encoder_model_name"""}   )
				SCREAMING_SNAKE_CASE_       :							Optional[str]							 =					field(
				    default=_UpperCamelCase    ,       metadata={"""help""": """Pretrained decoder config name or path if not the same as decoder_model_name"""}   )




def 			__magic_name__				( ):






			'''simple docstring'''







			a    =			HfArgumentParser((ModelArguments,)   )
			((a)    ,		)    =			parser.parse_args_into_dataclasses()

			# Load pretrained model and tokenizer

			# Use explicit specified encoder config
			if model_args.encoder_config_name:
						a    =			AutoConfig.from_pretrained(model_args.encoder_config_name   )
			# Use pretrained encoder model's config
			else:
						a    =			AutoConfig.from_pretrained(model_args.encoder_model_name_or_path   )

			# Use explicit specified decoder config
			if model_args.decoder_config_name:
						a    =			AutoConfig.from_pretrained(model_args.decoder_config_name   )
			# Use pretrained decoder model's config
			else:
						a    =			AutoConfig.from_pretrained(model_args.decoder_model_name_or_path   )

			# necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
			a    =			True
			a    =			True

			a    =			FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
			    encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path,  decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path,  encoder_config=A,  decoder_config=A,  )

			# GPT2 only has bos/eos tokens but not decoder_start/pad tokens
			a    =			decoder_config.decoder_start_token_id
			a    =			decoder_config.pad_token_id
			if decoder_start_token_id is None:
						a    =			decoder_config.bos_token_id
			if pad_token_id is None:
						a    =			decoder_config.eos_token_id

			# This is necessary to make Flax's generate() work
			a    =			decoder_config.eos_token_id
			a    =			decoder_start_token_id
			a    =			pad_token_id

			a    =			AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path   )

			a    =			AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path   )
			a    =			tokenizer.convert_ids_to_tokens(model.config.pad_token_id   )

			model.save_pretrained(model_args.output_dir   )
			image_processor.save_pretrained(model_args.output_dir   )
			tokenizer.save_pretrained(model_args.output_dir   )


if __name__ == "__main__":
		main()






