



'''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()
snake_case_					:      Union[str, Any]    			=    logging.get_logger(__name__)






def A__       (	UpperCAmelCase_				):
						_UpperCamelCase   :						str												=  ASTConfig()

						if "10-10" in model_name:
												pass
						elif "speech-commands" in model_name:
												_UpperCamelCase   :						Any												=  1_2_8
						elif "12-12" in model_name:
												_UpperCamelCase   :						Optional[int]												=  1_2
												_UpperCamelCase   :						Optional[Any]												=  1_2
						elif "14-14" in model_name:
												_UpperCamelCase   :						str												=  1_4
												_UpperCamelCase   :						List[str]												=  1_4
						elif "16-16" in model_name:
												_UpperCamelCase   :						List[str]												=  1_6
												_UpperCamelCase   :						Optional[int]												=  1_6
						else:
												raise ValueError('Model not supported'				)

						_UpperCamelCase   :						Dict												=  'huggingface/label-files'
						if "speech-commands" in model_name:
												_UpperCamelCase   :						List[str]												=  3_5
												_UpperCamelCase   :						Optional[int]												=  'speech-commands-v2-id2label.json'
						else:
												_UpperCamelCase   :						Any												=  5_2_7
												_UpperCamelCase   :						Tuple												=  'audioset-id2label.json'

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

						return config






def A__       (	UpperCAmelCase_				):






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

						return name






def A__       (	UpperCAmelCase_    ,    UpperCAmelCase_				):






						for key in orig_state_dict.copy().keys():
												_UpperCamelCase   :						List[str]												=  orig_state_dict.pop(_lowerCAmelCase				)

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

						return orig_state_dict






def A__       (	UpperCAmelCase_				):
						_UpperCamelCase   :						List[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(_lowerCAmelCase    ,    _lowerCAmelCase				)






@torch.no_grad()
def A__       (	UpperCAmelCase_    ,    UpperCAmelCase_    ,    UpperCAmelCase_=False				):
						_UpperCamelCase   :						Optional[Any]												=  get_audio_spectrogram_transformer_config(_lowerCAmelCase				)

						_UpperCamelCase   :						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
						_UpperCamelCase   :						Tuple												=  model_name_to_url[model_name]
						_UpperCamelCase   :						Tuple												=  torch.hub.load_state_dict_from_url(_lowerCAmelCase    ,    map_location='cpu'				)
						# remove some keys
						remove_keys(_lowerCAmelCase				)
						# rename some keys
						_UpperCamelCase   :						Tuple												=  convert_state_dict(_lowerCAmelCase    ,    _lowerCAmelCase				)

						# load 🤗 model
						_UpperCamelCase   :						List[str]												=  ASTForAudioClassification(_lowerCAmelCase				)
						model.eval()

						model.load_state_dict(_lowerCAmelCase				)

						# verify outputs on dummy input
						# source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
						_UpperCamelCase   :						List[str]												=  -4.2_677_393 if 'speech-commands' not in model_name else -6.845_978
						_UpperCamelCase   :						Optional[int]												=  4.5_689_974 if 'speech-commands' not in model_name else 5.5_654_526
						_UpperCamelCase   :						int												=  1_0_2_4 if 'speech-commands' not in model_name else 1_2_8
						_UpperCamelCase   :						List[str]												=  ASTFeatureExtractor(mean=_lowerCAmelCase    ,    std=_lowerCAmelCase    ,    max_length=_lowerCAmelCase				)

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

												_UpperCamelCase							,     _UpperCamelCase   :						Any												=  torchaudio.load(_lowerCAmelCase				)
												_UpperCamelCase   :						int												=  waveform.squeeze().numpy()

						_UpperCamelCase   :						Any												=  feature_extractor(_lowerCAmelCase    ,    sampling_rate=1_6_0_0_0    ,    return_tensors='pt'				)

						# forward pass
						_UpperCamelCase   :						Tuple												=  model(**_lowerCAmelCase				)
						_UpperCamelCase   :						Any												=  outputs.logits

						if model_name == "ast-finetuned-audioset-10-10-0.4593":
												_UpperCamelCase   :						Optional[int]												=  torch.tensor([-0.8_760, -7.0_042, -8.6_602]				)
						elif model_name == "ast-finetuned-audioset-10-10-0.450":
												_UpperCamelCase   :						Tuple												=  torch.tensor([-1.1_986, -7.0_903, -8.2_718]				)
						elif model_name == "ast-finetuned-audioset-10-10-0.448":
												_UpperCamelCase   :						Tuple												=  torch.tensor([-2.6_128, -8.0_080, -9.4_344]				)
						elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
												_UpperCamelCase   :						Any												=  torch.tensor([-1.5_080, -7.4_534, -8.8_917]				)
						elif model_name == "ast-finetuned-audioset-12-12-0.447":
												_UpperCamelCase   :						Dict												=  torch.tensor([-0.5_050, -6.5_833, -8.0_843]				)
						elif model_name == "ast-finetuned-audioset-14-14-0.443":
												_UpperCamelCase   :						Dict												=  torch.tensor([-0.3_826, -7.0_336, -8.2_413]				)
						elif model_name == "ast-finetuned-audioset-16-16-0.442":
												_UpperCamelCase   :						Any												=  torch.tensor([-1.2_113, -6.9_101, -8.3_470]				)
						elif model_name == "ast-finetuned-speech-commands-v2":
												_UpperCamelCase   :						Dict												=  torch.tensor([6.1_589, -8.0_566, -8.7_984]				)
						else:
												raise ValueError('Unknown model name'				)
						if not torch.allclose(logits[0, :3]    ,    _lowerCAmelCase    ,    atol=1E-4				):
												raise ValueError('Logits don\'t match'				)
						print('Looks ok!'				)

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

						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__":
					snake_case_					:      Optional[Any]    			=    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.'
					)

					snake_case_					:      str    			=    parser.parse_args()
					convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






# flake8: noqa
# Lint as: python3

from typing import Dict, List, Optional, Type

from .. import config
from ..utils import logging
from .formatting import (
    ArrowFormatter,
    CustomFormatter,
    Formatter,
    PandasFormatter,
    PythonFormatter,
    TensorFormatter,
    format_table,
    query_table,
)
from .np_formatter import NumpyFormatter


A				:       Union[str, Any]      =  logging.get_logger(__name__)

A				:       Dict[Optional[str], Type[Formatter]]      =  {}
A				:       Dict[Optional[str], str]      =  {}
A				:       Dict[Optional[str], Exception]      =  {}





def 						_lowerCAmelCase							(     _lowerCAmelCase   ,						_lowerCAmelCase   ,						_lowerCAmelCase = None   ,						)    ->						str:


						'''simple docstring'''






						__snake_case				=		aliases if aliases is not None else []
						if format_type in _FORMAT_TYPES:
												logger.warning(
												    F'''Overwriting format type \'{format_type}\' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})'''			)
						__snake_case				=		formatter_cls
						for alias in set(aliases + [format_type]			):
												if alias in _FORMAT_TYPES_ALIASES:
																		logger.warning(
																		    F'''Overwriting format type alias \'{alias}\' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})'''			)
												__snake_case				=		format_type





def 						_lowerCAmelCase							(     _lowerCAmelCase   ,						_lowerCAmelCase   ,						_lowerCAmelCase = None			)    ->						List[Any]:


						'''simple docstring'''






						__snake_case				=		aliases if aliases is not None else []
						for alias in set(aliases + [format_type]			):
												__snake_case				=		unavailable_error


# Here we define all the available formatting functions that can be used by `Dataset.set_format`
_register_formatter(PythonFormatter, None, aliases=['python'])
_register_formatter(ArrowFormatter, 'arrow', aliases=['pa', 'pyarrow'])
_register_formatter(NumpyFormatter, 'numpy', aliases=['np'])
_register_formatter(PandasFormatter, 'pandas', aliases=['pd'])
_register_formatter(CustomFormatter, 'custom')

if config.TORCH_AVAILABLE:
	from .torch_formatter import TorchFormatter

	_register_formatter(TorchFormatter, 'torch', aliases=['pt', 'pytorch'])
else:
	A				:       Any      =  ValueError('PyTorch needs to be installed to be able to return PyTorch tensors.')
	_register_unavailable_formatter(_torch_error, 'torch', aliases=['pt', 'pytorch'])

if config.TF_AVAILABLE:
	from .tf_formatter import TFFormatter

	_register_formatter(TFFormatter, 'tensorflow', aliases=['tf'])
else:
	A				:       Tuple      =  ValueError('Tensorflow needs to be installed to be able to return Tensorflow tensors.')
	_register_unavailable_formatter(_tf_error, 'tensorflow', aliases=['tf'])

if config.JAX_AVAILABLE:
	from .jax_formatter import JaxFormatter

	_register_formatter(JaxFormatter, 'jax', aliases=[])
else:
	A				:       Optional[int]      =  ValueError('JAX needs to be installed to be able to return JAX arrays.')
	_register_unavailable_formatter(_jax_error, 'jax', aliases=[])





def 						_lowerCAmelCase							(     _lowerCAmelCase			)    ->						Optional[str]:


						'''simple docstring'''






						if format_type in _FORMAT_TYPES_ALIASES:
												return _FORMAT_TYPES_ALIASES[format_type]
						else:
												return format_type





def 						_lowerCAmelCase							(     _lowerCAmelCase   ,						**_lowerCAmelCase			)    ->						Formatter:


						'''simple docstring'''






						__snake_case				=		get_format_type_from_alias(_lowerCAmelCase			)
						if format_type in _FORMAT_TYPES:
												return _FORMAT_TYPES[format_type](**_lowerCAmelCase			)
						if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE:
												raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type]
						else:
												raise ValueError(
												    F'''Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None			)}, but got \'{format_type}\''''			)





