






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







def 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase			) ->	Tuple:
     UpperCamelCase__			:   Any       				=  ASTConfig()

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

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

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

     return config







def 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase			) ->	Tuple:
     if "module.v" in name:
          UpperCamelCase__			:   Dict       				=  name.replace("module.v"					,    "audio_spectrogram_transformer"			)
     if "cls_token" in name:
          UpperCamelCase__			:   Optional[Any]       				=  name.replace("cls_token"					,    "embeddings.cls_token"			)
     if "dist_token" in name:
          UpperCamelCase__			:   List[str]       				=  name.replace("dist_token"					,    "embeddings.distillation_token"			)
     if "pos_embed" in name:
          UpperCamelCase__			:   Any       				=  name.replace("pos_embed"					,    "embeddings.position_embeddings"			)
     if "patch_embed.proj" in name:
          UpperCamelCase__			:   Optional[Any]       				=  name.replace("patch_embed.proj"					,    "embeddings.patch_embeddings.projection"			)
     # transformer blocks
     if "blocks" in name:
          UpperCamelCase__			:   str       				=  name.replace("blocks"					,    "encoder.layer"			)
     if "attn.proj" in name:
          UpperCamelCase__			:   Dict       				=  name.replace("attn.proj"					,    "attention.output.dense"			)
     if "attn" in name:
          UpperCamelCase__			:   Any       				=  name.replace("attn"					,    "attention.self"			)
     if "norm1" in name:
          UpperCamelCase__			:   int       				=  name.replace("norm1"					,    "layernorm_before"			)
     if "norm2" in name:
          UpperCamelCase__			:   int       				=  name.replace("norm2"					,    "layernorm_after"			)
     if "mlp.fc1" in name:
          UpperCamelCase__			:   Optional[int]       				=  name.replace("mlp.fc1"					,    "intermediate.dense"			)
     if "mlp.fc2" in name:
          UpperCamelCase__			:   List[str]       				=  name.replace("mlp.fc2"					,    "output.dense"			)
     # final layernorm
     if "audio_spectrogram_transformer.norm" in name:
          UpperCamelCase__			:   int       				=  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__			:   Tuple       				=  name.replace("module.mlp_head.1"					,    "classifier.dense"			)

     return name







def 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase					,    __lowerCAmelCase			) ->	Dict:
     for key in orig_state_dict.copy().keys():
          UpperCamelCase__			:   Optional[int]       				=  orig_state_dict.pop(__lowerCAmelCase			)

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

     return orig_state_dict







def 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase			) ->	Optional[int]:
     UpperCamelCase__			:   int       				=  [
         "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 		SCREAMING_SNAKE_CASE							(					__lowerCAmelCase					,    __lowerCAmelCase					,    __lowerCAmelCase=False			) ->	Optional[Any]:
     UpperCamelCase__			:   Any       				=  get_audio_spectrogram_transformer_config(__lowerCAmelCase			)

     UpperCamelCase__			:   Optional[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__			:   List[str]       				=  model_name_to_url[model_name]
     UpperCamelCase__			:   Optional[int]       				=  torch.hub.load_state_dict_from_url(__lowerCAmelCase					,    map_location="cpu"			)
     # remove some keys
     remove_keys(__lowerCAmelCase			)
     # rename some keys
     UpperCamelCase__			:   Any       				=  convert_state_dict(__lowerCAmelCase					,    __lowerCAmelCase			)

     # load 🤗 model
     UpperCamelCase__			:   int       				=  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__			:   Optional[int]       				=  -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__			:   Tuple       				=  1024 if "speech-commands" not in model_name else 128
     UpperCamelCase__			:   str       				=  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__			:   int       				=  dataset[0]["audio"]["array"]
     else:
          UpperCamelCase__			:   Union[str, Any]       				=  hf_hub_download(
              repo_id="nielsr/audio-spectogram-transformer-checkpoint"					,    filename="sample_audio.flac"					,    repo_type="dataset"					,    )

          UpperCamelCase__				,     UpperCamelCase__			:   str       				=  torchaudio.load(__lowerCAmelCase			)
          UpperCamelCase__			:   List[Any]       				=  waveform.squeeze().numpy()

     UpperCamelCase__			:   Optional[int]       				=  feature_extractor(__lowerCAmelCase					,    sampling_rate=1_6000					,    return_tensors="pt"			)

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

     if model_name == "ast-finetuned-audioset-10-10-0.4593":
          UpperCamelCase__			:   Union[str, Any]       				=  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__			:   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__			:   List[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__			:   Tuple       				=  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__			:   Tuple       				=  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__			:   int       				=  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__			:   Any       				=  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__			:   List[Any]       				=  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	:							str				=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	:							str				=parser.parse_args()
 convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







import copy
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


lowerCamelCase	:							Tuple				=logging.get_logger(__name__)

lowerCamelCase	:							Optional[Any]				={
    '''microsoft/conditional-detr-resnet-50''': (
        '''https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json'''
    ),
}





class 			__a  (    A__       ):
 _lowerCAmelCase       :       Optional[Any]        = '''conditional_detr'''
 _lowerCAmelCase       :       List[Any]        = ['''past_key_values''']
 _lowerCAmelCase       :       List[str]        = {
     '''hidden_size''': '''d_model''',
     '''num_attention_heads''': '''encoder_attention_heads''',
 }







 def __init__(		self					:   str							,   SCREAMING_SNAKE_CASE					:   Tuple=True							,   SCREAMING_SNAKE_CASE					:   Optional[int]=None							,   SCREAMING_SNAKE_CASE					:   Tuple=3							,   SCREAMING_SNAKE_CASE					:   Any=3_00							,   SCREAMING_SNAKE_CASE					:   Tuple=6							,   SCREAMING_SNAKE_CASE					:   int=20_48							,   SCREAMING_SNAKE_CASE					:   Union[str, Any]=8							,   SCREAMING_SNAKE_CASE					:   int=6							,   SCREAMING_SNAKE_CASE					:   Dict=20_48							,   SCREAMING_SNAKE_CASE					:   Optional[int]=8							,   SCREAMING_SNAKE_CASE					:   Dict=0.0							,   SCREAMING_SNAKE_CASE					:   List[Any]=0.0							,   SCREAMING_SNAKE_CASE					:   int=True							,   SCREAMING_SNAKE_CASE					:   int="relu"							,   SCREAMING_SNAKE_CASE					:   Any=2_56							,   SCREAMING_SNAKE_CASE					:   int=0.1							,   SCREAMING_SNAKE_CASE					:   int=0.0							,   SCREAMING_SNAKE_CASE					:   Optional[int]=0.0							,   SCREAMING_SNAKE_CASE					:   List[str]=0.0_2							,   SCREAMING_SNAKE_CASE					:   Optional[int]=1.0							,   SCREAMING_SNAKE_CASE					:   List[str]=False							,   SCREAMING_SNAKE_CASE					:   int="sine"							,   SCREAMING_SNAKE_CASE					:   str="resnet50"							,   SCREAMING_SNAKE_CASE					:   int=True							,   SCREAMING_SNAKE_CASE					:   Tuple=False							,   SCREAMING_SNAKE_CASE					:   Tuple=2							,   SCREAMING_SNAKE_CASE					:   Tuple=5							,   SCREAMING_SNAKE_CASE					:   List[str]=2							,   SCREAMING_SNAKE_CASE					:   List[str]=1							,   SCREAMING_SNAKE_CASE					:   Optional[Any]=1							,   SCREAMING_SNAKE_CASE					:   str=2							,   SCREAMING_SNAKE_CASE					:   Any=5							,   SCREAMING_SNAKE_CASE					:   int=2							,   SCREAMING_SNAKE_CASE					:   List[Any]=0.2_5							,   **SCREAMING_SNAKE_CASE					:   Union[str, Any]							,   ):


      '''simple docstring'''






      if backbone_config is not None and use_timm_backbone:
           raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`."						)

      if not use_timm_backbone:
           if backbone_config is None:
                logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."						)
                UpperCamelCase__			:   Tuple       				=  CONFIG_MAPPING["resnet"](out_features=["stage4"]						)
           elif isinstance(SCREAMING_SNAKE_CASE							,   SCREAMING_SNAKE_CASE						):
                UpperCamelCase__			:   Union[str, Any]       				=  backbone_config.get("model_type"						)
                UpperCamelCase__			:   Tuple       				=  CONFIG_MAPPING[backbone_model_type]
                UpperCamelCase__			:   Any       				=  config_class.from_dict(SCREAMING_SNAKE_CASE						)

      UpperCamelCase__			:   Optional[Any]       				=  use_timm_backbone
      UpperCamelCase__			:   List[Any]       				=  backbone_config
      UpperCamelCase__			:   Tuple       				=  num_channels
      UpperCamelCase__			:   List[Any]       				=  num_queries
      UpperCamelCase__			:   Dict       				=  d_model
      UpperCamelCase__			:   Any       				=  encoder_ffn_dim
      UpperCamelCase__			:   List[str]       				=  encoder_layers
      UpperCamelCase__			:   List[str]       				=  encoder_attention_heads
      UpperCamelCase__			:   Optional[int]       				=  decoder_ffn_dim
      UpperCamelCase__			:   str       				=  decoder_layers
      UpperCamelCase__			:   Optional[Any]       				=  decoder_attention_heads
      UpperCamelCase__			:   int       				=  dropout
      UpperCamelCase__			:   Optional[int]       				=  attention_dropout
      UpperCamelCase__			:   Any       				=  activation_dropout
      UpperCamelCase__			:   int       				=  activation_function
      UpperCamelCase__			:   int       				=  init_std
      UpperCamelCase__			:   List[Any]       				=  init_xavier_std
      UpperCamelCase__			:   List[str]       				=  encoder_layerdrop
      UpperCamelCase__			:   List[Any]       				=  decoder_layerdrop
      UpperCamelCase__			:   List[Any]       				=  encoder_layers
      UpperCamelCase__			:   Optional[Any]       				=  auxiliary_loss
      UpperCamelCase__			:   List[str]       				=  position_embedding_type
      UpperCamelCase__			:   Optional[Any]       				=  backbone
      UpperCamelCase__			:   Optional[int]       				=  use_pretrained_backbone
      UpperCamelCase__			:   List[Any]       				=  dilation
      # Hungarian matcher
      UpperCamelCase__			:   List[str]       				=  class_cost
      UpperCamelCase__			:   Union[str, Any]       				=  bbox_cost
      UpperCamelCase__			:   int       				=  giou_cost
      # Loss coefficients
      UpperCamelCase__			:   str       				=  mask_loss_coefficient
      UpperCamelCase__			:   List[Any]       				=  dice_loss_coefficient
      UpperCamelCase__			:   int       				=  cls_loss_coefficient
      UpperCamelCase__			:   Tuple       				=  bbox_loss_coefficient
      UpperCamelCase__			:   Any       				=  giou_loss_coefficient
      UpperCamelCase__			:   List[Any]       				=  focal_alpha
      super().__init__(is_encoder_decoder=SCREAMING_SNAKE_CASE							,   **SCREAMING_SNAKE_CASE						)







 @property
 def 					__lowercase					(		self					:   Union[str, Any]						):


      '''simple docstring'''






      return self.encoder_attention_heads







 @property
 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      return self.d_model







 def 					__lowercase					(		self					:   List[Any]						):


      '''simple docstring'''






      UpperCamelCase__			:   Any       				=  copy.deepcopy(self.__dict__						)
      if self.backbone_config is not None:
           UpperCamelCase__			:   List[str]       				=  self.backbone_config.to_dict()
      UpperCamelCase__			:   int       				=  self.__class__.model_type
      return output







class 			__a  (    A__       ):
 _lowerCAmelCase       :       Tuple        = version.parse('''1.11'''       )







 @property
 def 					__lowercase					(		self					:   Any						):


      '''simple docstring'''






      return OrderedDict(
          [
              ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
              ("pixel_mask", {0: "batch"}),
          ]						)







 @property
 def 					__lowercase					(		self					:   Tuple						):


      '''simple docstring'''






      return 1e-5







 @property
 def 					__lowercase					(		self					:   List[str]						):


      '''simple docstring'''






      return 12