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






def 							A		(       snake_case   :str	)   ->			Dict:
 __UpperCamelCase       						= ASTConfig()

 if "10-10" in model_name:
  pass
 elif "speech-commands" in model_name:
  __UpperCamelCase       						= 1_2_8
 elif "12-12" in model_name:
  __UpperCamelCase       						= 1_2
  __UpperCamelCase       						= 1_2
 elif "14-14" in model_name:
  __UpperCamelCase       						= 1_4
  __UpperCamelCase       						= 1_4
 elif "16-16" in model_name:
  __UpperCamelCase       						= 1_6
  __UpperCamelCase       						= 1_6
 else:
  raise ValueError('Model not supported'	)

 __UpperCamelCase       						= 'huggingface/label-files'
 if "speech-commands" in model_name:
  __UpperCamelCase       						= 3_5
  __UpperCamelCase       						= 'speech-commands-v2-id2label.json'
 else:
  __UpperCamelCase       						= 5_2_7
  __UpperCamelCase       						= 'audioset-id2label.json'

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

 return config






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

 return name






def 							A		(       snake_case   :Optional[Any]       ,      snake_case   :List[str]	)   ->			str:
 for key in orig_state_dict.copy().keys():
  __UpperCamelCase       						= orig_state_dict.pop(snake_case	)

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

 return orig_state_dict






def 							A		(       snake_case   :str	)   ->			Optional[int]:
 __UpperCamelCase       						= [
     '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 							A		(       snake_case   :Optional[int]       ,      snake_case   :Any       ,      snake_case   :Dict=False	)   ->			Tuple:
 __UpperCamelCase       						= get_audio_spectrogram_transformer_config(snake_case	)

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

 # load 🤗 model
 __UpperCamelCase       						= 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
 __UpperCamelCase       						= -4.2_677_393 if 'speech-commands' not in model_name else -6.845_978
 __UpperCamelCase       						= 4.5_689_974 if 'speech-commands' not in model_name else 5.5_654_526
 __UpperCamelCase       						= 1_0_2_4 if 'speech-commands' not in model_name else 1_2_8
 __UpperCamelCase       						= ASTFeatureExtractor(mean=snake_case       ,      std=snake_case       ,      max_length=snake_case	)

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

  __UpperCamelCase						,			__UpperCamelCase       						= torchaudio.load(snake_case	)
  __UpperCamelCase       						= waveform.squeeze().numpy()

 __UpperCamelCase       						= feature_extractor(snake_case       ,      sampling_rate=1_6_0_0_0       ,      return_tensors='pt'	)

 # forward pass
 __UpperCamelCase       						= model(**snake_case	)
 __UpperCamelCase       						= outputs.logits

 if model_name == "ast-finetuned-audioset-10-10-0.4593":
  __UpperCamelCase       						= torch.tensor([-0.8_760, -7.0_042, -8.6_602]	)
 elif model_name == "ast-finetuned-audioset-10-10-0.450":
  __UpperCamelCase       						= torch.tensor([-1.1_986, -7.0_903, -8.2_718]	)
 elif model_name == "ast-finetuned-audioset-10-10-0.448":
  __UpperCamelCase       						= torch.tensor([-2.6_128, -8.0_080, -9.4_344]	)
 elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
  __UpperCamelCase       						= torch.tensor([-1.5_080, -7.4_534, -8.8_917]	)
 elif model_name == "ast-finetuned-audioset-12-12-0.447":
  __UpperCamelCase       						= torch.tensor([-0.5_050, -6.5_833, -8.0_843]	)
 elif model_name == "ast-finetuned-audioset-14-14-0.443":
  __UpperCamelCase       						= torch.tensor([-0.3_826, -7.0_336, -8.2_413]	)
 elif model_name == "ast-finetuned-audioset-16-16-0.442":
  __UpperCamelCase       						= torch.tensor([-1.2_113, -6.9_101, -8.3_470]	)
 elif model_name == "ast-finetuned-speech-commands-v2":
  __UpperCamelCase       						= torch.tensor([6.1_589, -8.0_566, -8.7_984]	)
 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__":
      UpperCamelCase			:       Dict									=				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."
      )

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





"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase			:       List[Any]									=				{
    "configuration_xlm_roberta": [
        "XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "XLMRobertaConfig",
        "XLMRobertaOnnxConfig",
    ],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase			:       Optional[Any]									=				["XLMRobertaTokenizer"]

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase			:       int									=				["XLMRobertaTokenizerFast"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase			:       Optional[int]									=				[
          "XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
          "XLMRobertaForCausalLM",
          "XLMRobertaForMaskedLM",
          "XLMRobertaForMultipleChoice",
          "XLMRobertaForQuestionAnswering",
          "XLMRobertaForSequenceClassification",
          "XLMRobertaForTokenClassification",
          "XLMRobertaModel",
          "XLMRobertaPreTrainedModel",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase			:       List[str]									=				[
          "TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFXLMRobertaForCausalLM",
          "TFXLMRobertaForMaskedLM",
          "TFXLMRobertaForMultipleChoice",
          "TFXLMRobertaForQuestionAnswering",
          "TFXLMRobertaForSequenceClassification",
          "TFXLMRobertaForTokenClassification",
          "TFXLMRobertaModel",
          "TFXLMRobertaPreTrainedModel",
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase			:       List[str]									=				[
          "FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST",
          "FlaxXLMRobertaForMaskedLM",
          "FlaxXLMRobertaForCausalLM",
          "FlaxXLMRobertaForMultipleChoice",
          "FlaxXLMRobertaForQuestionAnswering",
          "FlaxXLMRobertaForSequenceClassification",
          "FlaxXLMRobertaForTokenClassification",
          "FlaxXLMRobertaModel",
          "FlaxXLMRobertaPreTrainedModel",
      ]

if TYPE_CHECKING:
      from .configuration_xlm_roberta import (
          XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
          XLMRobertaConfig,
          XLMRobertaOnnxConfig,
      )

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_xlm_roberta import XLMRobertaTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_xlm_roberta import (
                XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                XLMRobertaForCausalLM,
                XLMRobertaForMaskedLM,
                XLMRobertaForMultipleChoice,
                XLMRobertaForQuestionAnswering,
                XLMRobertaForSequenceClassification,
                XLMRobertaForTokenClassification,
                XLMRobertaModel,
                XLMRobertaPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_xlm_roberta import (
                TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFXLMRobertaForCausalLM,
                TFXLMRobertaForMaskedLM,
                TFXLMRobertaForMultipleChoice,
                TFXLMRobertaForQuestionAnswering,
                TFXLMRobertaForSequenceClassification,
                TFXLMRobertaForTokenClassification,
                TFXLMRobertaModel,
                TFXLMRobertaPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_xlm_roberta import (
                FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                FlaxXLMRobertaForCausalLM,
                FlaxXLMRobertaForMaskedLM,
                FlaxXLMRobertaForMultipleChoice,
                FlaxXLMRobertaForQuestionAnswering,
                FlaxXLMRobertaForSequenceClassification,
                FlaxXLMRobertaForTokenClassification,
                FlaxXLMRobertaModel,
                FlaxXLMRobertaPreTrainedModel,
            )

else:
      import sys

      UpperCamelCase			:       Dict									=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



