





'''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_					:    List[str]      	=			logging.get_logger(__name__)






def  _lowerCamelCase				( lowercase						:      List[str]						)	->	str:
				_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(_a    ,							_a    ,							repo_type="dataset"						)    ,							"r"						)						)
				_a								= {int(_a						): v for k, v in idalabel.items()}
				_a								= idalabel
				_a								= {v: k for k, v in idalabel.items()}

				return config






def  _lowerCamelCase				( lowercase						:      Tuple						)	->	List[str]:
				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  _lowerCamelCase				( lowercase						:      Dict    ,							lowercase						:      List[Any]						)	->	Any:
				for key in orig_state_dict.copy().keys():
								_a								= orig_state_dict.pop(_a						)

								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  _lowerCamelCase				( lowercase						:      Tuple						)	->	str:
				_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(_a    ,							_a						)






@torch.no_grad()
def  _lowerCamelCase				( lowercase						:      int    ,							lowercase						:      Union[str, Any]    ,							lowercase						:      Dict=False						)	->	List[Any]:
				_a								= get_audio_spectrogram_transformer_config(_a						)

				_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(_a    ,							map_location="cpu"						)
				# remove some keys
				remove_keys(_a						)
				# rename some keys
				_a								= convert_state_dict(_a    ,							_a						)

				# load 🤗 model
				_a								= 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
				_a								= -4.2_67_73_93 if "speech-commands" not in model_name else -6.84_59_78
				_a								= 4.5_68_99_74 if "speech-commands" not in model_name else 5.5_65_45_26
				_a								= 1024 if "speech-commands" not in model_name else 128
				_a								= ASTFeatureExtractor(mean=_a    ,							std=_a    ,							max_length=_a						)

				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(_a						)
								_a								= waveform.squeeze().numpy()

				_a								= feature_extractor(_a    ,							sampling_rate=1_6000    ,							return_tensors="pt"						)

				# forward pass
				_a								= model(**_a						)
				_a								= outputs.logits

				if model_name == "ast-finetuned-audioset-10-10-0.4593":
								_a								= torch.tensor([-0.87_60, -7.00_42, -8.66_02]						)
				elif model_name == "ast-finetuned-audioset-10-10-0.450":
								_a								= torch.tensor([-1.19_86, -7.09_03, -8.27_18]						)
				elif model_name == "ast-finetuned-audioset-10-10-0.448":
								_a								= torch.tensor([-2.61_28, -8.00_80, -9.43_44]						)
				elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
								_a								= torch.tensor([-1.50_80, -7.45_34, -8.89_17]						)
				elif model_name == "ast-finetuned-audioset-12-12-0.447":
								_a								= torch.tensor([-0.50_50, -6.58_33, -8.08_43]						)
				elif model_name == "ast-finetuned-audioset-14-14-0.443":
								_a								= torch.tensor([-0.38_26, -7.03_36, -8.24_13]						)
				elif model_name == "ast-finetuned-audioset-16-16-0.442":
								_a								= torch.tensor([-1.21_13, -6.91_01, -8.34_70]						)
				elif model_name == "ast-finetuned-speech-commands-v2":
								_a								= torch.tensor([6.15_89, -8.05_66, -8.79_84]						)
				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__":
					lowerCAmelCase_					:    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.'
					)

					lowerCAmelCase_					:    Optional[int]      	=			parser.parse_args()
					convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






'''simple docstring'''







import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding


class 			_a  (	__a ):
       __a				:     int   				=					["""image_processor""", """tokenizer"""]
       __a				:     Union[str, Any]   				=					"""ChineseCLIPImageProcessor"""
       __a				:     List[Any]   				=					("""BertTokenizer""", """BertTokenizerFast""")
       def __init__(	self						:	Dict   ,				lowercase						:	Union[str, Any]=None   ,				lowercase						:	Dict=None   ,				**lowercase						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		None
           if "feature_extractor" in kwargs:
               warnings.warn(
                   '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
                   ''' instead.'''   ,				lowercase   ,				)
               UpperCAmelCase			       =		kwargs.pop('''feature_extractor'''				)

           UpperCAmelCase			       =		image_processor if image_processor is not None else feature_extractor
           if image_processor is None:
               raise ValueError('''You need to specify an `image_processor`.'''				)
           if tokenizer is None:
               raise ValueError('''You need to specify a `tokenizer`.'''				)

           super().__init__(lowercase   ,				lowercase				)
           UpperCAmelCase			       =		self.image_processor
       def __call__(	self						:	Tuple   ,				lowercase						:	Optional[Any]=None   ,				lowercase						:	Union[str, Any]=None   ,				lowercase						:	int=None   ,				**lowercase						:	Dict				):



           '''simple docstring'''

           if text is None and images is None:
               raise ValueError('''You have to specify either text or images. Both cannot be none.'''				)

           if text is not None:
               UpperCAmelCase			       =		self.tokenizer(lowercase   ,				return_tensors=lowercase   ,				**lowercase				)

           if images is not None:
               UpperCAmelCase			       =		self.image_processor(lowercase   ,				return_tensors=lowercase   ,				**lowercase				)

           if text is not None and images is not None:
               UpperCAmelCase			       =		image_features.pixel_values
               return encoding
           elif text is not None:
               return encoding
           else:
               return BatchEncoding(data=dict(**lowercase				)   ,				tensor_type=lowercase				)
       def     A      (	self						:	int   ,				*lowercase						:	Tuple   ,				**lowercase						:	List[str]				):



           '''simple docstring'''

           return self.tokenizer.batch_decode(*lowercase   ,				**lowercase				)
       def     A      (	self						:	Optional[Any]   ,				*lowercase						:	int   ,				**lowercase						:	Optional[int]				):



           '''simple docstring'''

           return self.tokenizer.decode(*lowercase   ,				**lowercase				)
       @property
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.tokenizer.model_input_names
           UpperCAmelCase			       =		self.image_processor.model_input_names
           return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names				)				)







       @property
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           warnings.warn(
               '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''   ,				lowercase   ,				)
           return self.image_processor_class




