


'''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        __lowerCAmelCase       (__lowerCAmelCase      ):
		_UpperCAmelCase						:				List[str]	    =					ASTConfig()

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

		_UpperCAmelCase						:				Dict	    =					"huggingface/label-files"
		if "speech-commands" in model_name:
				_UpperCAmelCase						:				Tuple	    =					35
				_UpperCAmelCase						:				Optional[int]	    =					"speech-commands-v2-id2label.json"
		else:
				_UpperCAmelCase						:				Dict	    =					527
				_UpperCAmelCase						:				List[Any]	    =					"audioset-id2label.json"

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

		return config






def        __lowerCAmelCase       (__lowerCAmelCase      ):
		if "module.v" in name:
				_UpperCAmelCase						:				int	    =					name.replace("module.v"					,       "audio_spectrogram_transformer"      )
		if "cls_token" in name:
				_UpperCAmelCase						:				Tuple	    =					name.replace("cls_token"					,       "embeddings.cls_token"      )
		if "dist_token" in name:
				_UpperCAmelCase						:				List[Any]	    =					name.replace("dist_token"					,       "embeddings.distillation_token"      )
		if "pos_embed" in name:
				_UpperCAmelCase						:				str	    =					name.replace("pos_embed"					,       "embeddings.position_embeddings"      )
		if "patch_embed.proj" in name:
				_UpperCAmelCase						:				Optional[int]	    =					name.replace("patch_embed.proj"					,       "embeddings.patch_embeddings.projection"      )
		# transformer blocks
		if "blocks" in name:
				_UpperCAmelCase						:				Optional[int]	    =					name.replace("blocks"					,       "encoder.layer"      )
		if "attn.proj" in name:
				_UpperCAmelCase						:				List[str]	    =					name.replace("attn.proj"					,       "attention.output.dense"      )
		if "attn" in name:
				_UpperCAmelCase						:				Optional[int]	    =					name.replace("attn"					,       "attention.self"      )
		if "norm1" in name:
				_UpperCAmelCase						:				Union[str, Any]	    =					name.replace("norm1"					,       "layernorm_before"      )
		if "norm2" in name:
				_UpperCAmelCase						:				Union[str, Any]	    =					name.replace("norm2"					,       "layernorm_after"      )
		if "mlp.fc1" in name:
				_UpperCAmelCase						:				List[Any]	    =					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						:				List[str]	    =					name.replace("audio_spectrogram_transformer.norm"					,       "audio_spectrogram_transformer.layernorm"      )
		# classifier head
		if "module.mlp_head.0" in name:
				_UpperCAmelCase						:				Dict	    =					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        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase      ):
		for key in orig_state_dict.copy().keys():
				_UpperCAmelCase						:				int	    =					orig_state_dict.pop(__lowerCAmelCase      )

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

		return orig_state_dict






def        __lowerCAmelCase       (__lowerCAmelCase      ):
		_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        __lowerCAmelCase       (__lowerCAmelCase					,       __lowerCAmelCase					,       __lowerCAmelCase=False      ):
		_UpperCAmelCase						:				List[Any]	    =					get_audio_spectrogram_transformer_config(__lowerCAmelCase      )

		_UpperCAmelCase						:				List[Any]	    =					{
		    "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						:				Dict	    =					model_name_to_url[model_name]
		_UpperCAmelCase						:				List[str]	    =					torch.hub.load_state_dict_from_url(__lowerCAmelCase					,       map_location="cpu"      )
		# remove some keys
		remove_keys(__lowerCAmelCase      )
		# rename some keys
		_UpperCAmelCase						:				str	    =					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						:				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
		_UpperCAmelCase						:				Any	    =					4.5_6_8_9_9_7_4 if "speech-commands" not in model_name else 5.5_6_5_4_5_2_6
		_UpperCAmelCase						:				Optional[Any]	    =					1_024 if "speech-commands" not in model_name else 128
		_UpperCAmelCase						:				Dict	    =					ASTFeatureExtractor(mean=__lowerCAmelCase					,       std=__lowerCAmelCase					,       max_length=__lowerCAmelCase      )

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

				_UpperCAmelCase    ,			_UpperCAmelCase						:				Optional[int]	    =					torchaudio.load(__lowerCAmelCase      )
				_UpperCAmelCase						:				List[Any]	    =					waveform.squeeze().numpy()

		_UpperCAmelCase						:				List[str]	    =					feature_extractor(__lowerCAmelCase					,       sampling_rate=16_000					,       return_tensors="pt"      )

		# forward pass
		_UpperCAmelCase						:				Optional[int]	    =					model(**__lowerCAmelCase      )
		_UpperCAmelCase						:				Optional[Any]	    =					outputs.logits

		if model_name == "ast-finetuned-audioset-10-10-0.4593":
				_UpperCAmelCase						:				List[str]	    =					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":
				_UpperCAmelCase						:				List[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":
				_UpperCAmelCase						:				Any	    =					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":
				_UpperCAmelCase						:				Union[str, Any]	    =					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":
				_UpperCAmelCase						:				Union[str, Any]	    =					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":
				_UpperCAmelCase						:				Optional[Any]	    =					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":
				_UpperCAmelCase						:				int	    =					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":
				_UpperCAmelCase						:				Optional[int]	    =					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]					,       __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__":
						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 os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


lowerCamelCase__					=   logging.get_logger(__name__)

lowerCamelCase__					=   {'vocab_file': 'sentencepiece.bpe.model'}

lowerCamelCase__					=   {
    'vocab_file': {
        'moussaKam/mbarthez': 'https://huggingface.co/moussaKam/mbarthez/resolve/main/sentencepiece.bpe.model',
        'moussaKam/barthez': 'https://huggingface.co/moussaKam/barthez/resolve/main/sentencepiece.bpe.model',
        'moussaKam/barthez-orangesum-title': (
            'https://huggingface.co/moussaKam/barthez-orangesum-title/resolve/main/sentencepiece.bpe.model'
        ),
    },
}

lowerCamelCase__					=   {
    'moussaKam/mbarthez': 1_024,
    'moussaKam/barthez': 1_024,
    'moussaKam/barthez-orangesum-title': 1_024,
}

lowerCamelCase__					=   '▁'






class 		lowerCAmelCase__	(	UpperCAmelCase__		):
			lowerCAmelCase       :		Any				      =   VOCAB_FILES_NAMES
			lowerCAmelCase       :		Any				      =   PRETRAINED_VOCAB_FILES_MAP
			lowerCAmelCase       :		Union[str, Any]				      =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			lowerCAmelCase       :		int				      =   ["input_ids", "attention_mask"]




			def __init__(						self     :   int		,     lowerCamelCase__     :   Tuple		,     lowerCamelCase__     :   List[Any]="<s>"		,     lowerCamelCase__     :   Dict="</s>"		,     lowerCamelCase__     :   Union[str, Any]="</s>"		,     lowerCamelCase__     :   List[Any]="<s>"		,     lowerCamelCase__     :   List[str]="<unk>"		,     lowerCamelCase__     :   str="<pad>"		,     lowerCamelCase__     :   Tuple="<mask>"		,     lowerCamelCase__     :   Optional[Dict[str, Any]] = None		,     **lowerCamelCase__     :   Dict		,     )      ->None:



					'''simple docstring'''







					_UpperCAmelCase						:				Dict	    =					AddedToken(lowerCamelCase__		,     lstrip=lowerCamelCase__		,     rstrip=lowerCamelCase__       ) if isinstance(lowerCamelCase__		,     lowerCamelCase__       ) else mask_token

					_UpperCAmelCase						:				Any	    =					{} if sp_model_kwargs is None else sp_model_kwargs

					super().__init__(
					    bos_token=lowerCamelCase__		,     eos_token=lowerCamelCase__		,     unk_token=lowerCamelCase__		,     sep_token=lowerCamelCase__		,     cls_token=lowerCamelCase__		,     pad_token=lowerCamelCase__		,     mask_token=lowerCamelCase__		,     sp_model_kwargs=self.sp_model_kwargs		,     **lowerCamelCase__		,     )

					_UpperCAmelCase						:				Union[str, Any]	    =					vocab_file
					_UpperCAmelCase						:				Dict	    =					spm.SentencePieceProcessor(**self.sp_model_kwargs       )
					self.sp_model.Load(str(lowerCamelCase__       )       )

					_UpperCAmelCase						:				Optional[int]	    =					{"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

					_UpperCAmelCase						:				List[str]	    =					len(self.sp_model       ) - 1
					_UpperCAmelCase						:				List[str]	    =					{v: k for k, v in self.fairseq_tokens_to_ids.items()}




			def 							lowerCAmelCase__			(						self     :   Dict		,     lowerCamelCase__     :   List[int]		,     lowerCamelCase__     :   Optional[List[int]] = None       )      ->List[int]:



					'''simple docstring'''







					if token_ids_a is None:
							return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
					_UpperCAmelCase						:				Union[str, Any]	    =					[self.cls_token_id]
					_UpperCAmelCase						:				str	    =					[self.sep_token_id]
					return cls + token_ids_a + sep + sep + token_ids_a + sep




			def 							lowerCAmelCase__			(						self     :   int		,     lowerCamelCase__     :   List[int]		,     lowerCamelCase__     :   Optional[List[int]] = None		,     lowerCamelCase__     :   bool = False       )      ->List[int]:



					'''simple docstring'''







					if already_has_special_tokens:
							return super().get_special_tokens_mask(
							    token_ids_a=lowerCamelCase__		,     token_ids_a=lowerCamelCase__		,     already_has_special_tokens=lowerCamelCase__       )

					if token_ids_a is None:
							return [1] + ([0] * len(lowerCamelCase__       )) + [1]
					return [1] + ([0] * len(lowerCamelCase__       )) + [1, 1] + ([0] * len(lowerCamelCase__       )) + [1]




			def 							lowerCAmelCase__			(						self     :   List[str]		,     lowerCamelCase__     :   List[int]		,     lowerCamelCase__     :   Optional[List[int]] = None       )      ->List[int]:



					'''simple docstring'''







					_UpperCAmelCase						:				Optional[int]	    =					[self.sep_token_id]
					_UpperCAmelCase						:				Optional[int]	    =					[self.cls_token_id]

					if token_ids_a is None:
							return len(cls + token_ids_a + sep       ) * [0]
					return len(cls + token_ids_a + sep + sep + token_ids_a + sep       ) * [0]




			@property
			def 							lowerCAmelCase__			(						self     :   List[Any]       )      ->List[str]:



					'''simple docstring'''







					return len(self.sp_model       )




			def 							lowerCAmelCase__			(						self     :   int       )      ->int:



					'''simple docstring'''







					_UpperCAmelCase						:				List[Any]	    =					{self.convert_ids_to_tokens(lowerCamelCase__       ): i for i in range(self.vocab_size       )}
					vocab.update(self.added_tokens_encoder       )
					return vocab




			def 							lowerCAmelCase__			(						self     :   int		,     lowerCamelCase__     :   str       )      ->List[str]:



					'''simple docstring'''







					return self.sp_model.encode(lowerCamelCase__		,     out_type=lowerCamelCase__       )




			def 							lowerCAmelCase__			(						self     :   Dict		,     lowerCamelCase__     :   Union[str, Any]       )      ->List[Any]:



					'''simple docstring'''







					if token in self.fairseq_tokens_to_ids:
							return self.fairseq_tokens_to_ids[token]
					_UpperCAmelCase						:				Optional[Any]	    =					self.sp_model.PieceToId(lowerCamelCase__       )

					return spm_id if spm_id else self.unk_token_id




			def 							lowerCAmelCase__			(						self     :   str		,     lowerCamelCase__     :   Any       )      ->Optional[Any]:



					'''simple docstring'''







					if index in self.fairseq_ids_to_tokens:
							return self.fairseq_ids_to_tokens[index]
					return self.sp_model.IdToPiece(lowerCamelCase__       )




			def 							lowerCAmelCase__			(						self     :   Any		,     lowerCamelCase__     :   List[Any]       )      ->Optional[int]:



					'''simple docstring'''







					_UpperCAmelCase						:				Union[str, Any]	    =					[]
					_UpperCAmelCase						:				Optional[Any]	    =					""
					_UpperCAmelCase						:				Optional[int]	    =					False
					for token in tokens:
							# make sure that special tokens are not decoded using sentencepiece model
							if token in self.all_special_tokens:
									if not prev_is_special:
											out_string += " "
									out_string += self.sp_model.decode(lowerCamelCase__       ) + token
									_UpperCAmelCase						:				Union[str, Any]	    =					True
									_UpperCAmelCase						:				Union[str, Any]	    =					[]
							else:
									current_sub_tokens.append(lowerCamelCase__       )
									_UpperCAmelCase						:				int	    =					False
					out_string += self.sp_model.decode(lowerCamelCase__       )
					return out_string.strip()




			def __getstate__(						self     :   Dict       )      ->List[Any]:



					'''simple docstring'''







					_UpperCAmelCase						:				List[str]	    =					self.__dict__.copy()
					_UpperCAmelCase						:				Optional[int]	    =					None
					return state




			def __setstate__(						self     :   Any		,     lowerCamelCase__     :   Dict       )      ->Tuple:



					'''simple docstring'''







					_UpperCAmelCase						:				Dict	    =					d

					# for backward compatibility
					if not hasattr(self		,     "sp_model_kwargs"       ):
							_UpperCAmelCase						:				List[Any]	    =					{}

					_UpperCAmelCase						:				Optional[int]	    =					spm.SentencePieceProcessor(**self.sp_model_kwargs       )
					self.sp_model.Load(self.vocab_file       )






			def 							lowerCAmelCase__			(						self     :   Optional[Any]		,     lowerCamelCase__     :   str		,     lowerCamelCase__     :   Optional[str] = None       )      ->Tuple[str]:



					'''simple docstring'''







					if not os.path.isdir(lowerCamelCase__       ):
							logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""       )
							return
					_UpperCAmelCase						:				Union[str, Any]	    =					os.path.join(
					    lowerCamelCase__		,     (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]       )

					if os.path.abspath(self.vocab_file       ) != os.path.abspath(lowerCamelCase__       ) and os.path.isfile(self.vocab_file       ):
							copyfile(self.vocab_file		,     lowerCamelCase__       )
					elif not os.path.isfile(self.vocab_file       ):
							with open(lowerCamelCase__		,     "wb"       ) as fi:
									_UpperCAmelCase						:				Dict	    =					self.sp_model.serialized_model_proto()
									fi.write(lowerCamelCase__       )

					return (out_vocab_file,)



