"""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					(	UpperCamelCase__				):






							"""simple docstring"""





							A__	     =							ASTConfig()

							if "10-10" in model_name:
														pass
							elif "speech-commands" in model_name:
														A__	     =							128
							elif "12-12" in model_name:
														A__	     =							12
														A__	     =							12
							elif "14-14" in model_name:
														A__	     =							14
														A__	     =							14
							elif "16-16" in model_name:
														A__	     =							16
														A__	     =							16
							else:
														raise ValueError('Model not supported'				)

							A__	     =							'huggingface/label-files'
							if "speech-commands" in model_name:
														A__	     =							35
														A__	     =							'speech-commands-v2-id2label.json'
							else:
														A__	     =							527
														A__	     =							'audioset-id2label.json'

							A__	     =							json.load(open(hf_hub_download(_snake_case       ,    _snake_case       ,    repo_type='dataset'				)       ,    'r'				)				)
							A__	     =							{int(_snake_case				): v for k, v in idalabel.items()}
							A__	     =							idalabel
							A__	     =							{v: k for k, v in idalabel.items()}

							return config






def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





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

							return name






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							for key in orig_state_dict.copy().keys():
														A__	     =							orig_state_dict.pop(_snake_case				)

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

							return orig_state_dict






def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							A__	     =							[
							    '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   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__=False				):






							"""simple docstring"""





							A__	     =							get_audio_spectrogram_transformer_config(_snake_case				)

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

							# load 🤗 model
							A__	     =							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
							A__	     =							-4.2_6_7_7_3_9_3 if 'speech-commands' not in model_name else -6.8_4_5_9_7_8
							A__	     =							4.5_6_8_9_9_7_4 if 'speech-commands' not in model_name else 5.5_6_5_4_5_2_6
							A__	     =							1_024 if 'speech-commands' not in model_name else 128
							A__	     =							ASTFeatureExtractor(mean=_snake_case       ,    std=_snake_case       ,    max_length=_snake_case				)

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

														A__     ,  A__	     =							torchaudio.load(_snake_case				)
														A__	     =							waveform.squeeze().numpy()

							A__	     =							feature_extractor(_snake_case       ,    sampling_rate=16_000       ,    return_tensors='pt'				)

							# forward pass
							A__	     =							model(**_snake_case				)
							A__	     =							outputs.logits

							if model_name == "ast-finetuned-audioset-10-10-0.4593":
														A__	     =							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":
														A__	     =							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":
														A__	     =							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":
														A__	     =							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":
														A__	     =							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":
														A__	     =							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":
														A__	     =							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":
														A__	     =							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]       ,    _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__":
		__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)






"""simple docstring"""




import torch
from transformers import PreTrainedModel, XLMRobertaConfig, XLMRobertaModel
class     UpperCamelCase__(			__A ):
						lowerCAmelCase__  :						Union[str, Any]													=		'M-CLIP'





						def __init__(       self		,__UpperCAmelCase=10_24		,__UpperCAmelCase=7_68		,**__UpperCAmelCase     )					->				List[str]:
													A__	     =							transformerDimSize
													A__	     =							imageDimSize
													super().__init__(**__UpperCAmelCase     )






class     UpperCamelCase__(			__A ):
						lowerCAmelCase__  :						Union[str, Any]													=		MCLIPConfig





						def __init__(       self		,__UpperCAmelCase		,*__UpperCAmelCase		,**__UpperCAmelCase     )					->				List[Any]:
													super().__init__(__UpperCAmelCase		,*__UpperCAmelCase		,**__UpperCAmelCase     )
													A__	     =							XLMRobertaModel(__UpperCAmelCase     )
													A__	     =							torch.nn.Linear(
													    in_features=config.transformerDimensions		,out_features=config.numDims     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Tuple:
													A__	     =							self.transformer(input_ids=__UpperCAmelCase		,attention_mask=__UpperCAmelCase     )[0]
													A__	     =							(embs * attention_mask.unsqueeze(2     )).sum(dim=1     ) / attention_mask.sum(dim=1     )[:, None]
													return self.LinearTransformation(__UpperCAmelCase     ), embs





