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


def     __magic_name__      ( __snake_case							:			Any    )					->							str:
       lowercase       :							List[Any]									=				ASTConfig()

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

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

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

       return config


def     __magic_name__      ( __snake_case							:			str    )					->							Any:
       if "module.v" in name:
              lowercase       :							List[Any]									=				name.replace("module.v"	,					"audio_spectrogram_transformer"    )
       if "cls_token" in name:
              lowercase       :							Any									=				name.replace("cls_token"	,					"embeddings.cls_token"    )
       if "dist_token" in name:
              lowercase       :							Optional[Any]									=				name.replace("dist_token"	,					"embeddings.distillation_token"    )
       if "pos_embed" in name:
              lowercase       :							Tuple									=				name.replace("pos_embed"	,					"embeddings.position_embeddings"    )
       if "patch_embed.proj" in name:
              lowercase       :							List[str]									=				name.replace("patch_embed.proj"	,					"embeddings.patch_embeddings.projection"    )
       # transformer blocks
       if "blocks" in name:
              lowercase       :							Dict									=				name.replace("blocks"	,					"encoder.layer"    )
       if "attn.proj" in name:
              lowercase       :							str									=				name.replace("attn.proj"	,					"attention.output.dense"    )
       if "attn" in name:
              lowercase       :							List[Any]									=				name.replace("attn"	,					"attention.self"    )
       if "norm1" in name:
              lowercase       :							Union[str, Any]									=				name.replace("norm1"	,					"layernorm_before"    )
       if "norm2" in name:
              lowercase       :							int									=				name.replace("norm2"	,					"layernorm_after"    )
       if "mlp.fc1" in name:
              lowercase       :							str									=				name.replace("mlp.fc1"	,					"intermediate.dense"    )
       if "mlp.fc2" in name:
              lowercase       :							List[str]									=				name.replace("mlp.fc2"	,					"output.dense"    )
       # final layernorm
       if "audio_spectrogram_transformer.norm" in name:
              lowercase       :							Optional[int]									=				name.replace("audio_spectrogram_transformer.norm"	,					"audio_spectrogram_transformer.layernorm"    )
       # classifier head
       if "module.mlp_head.0" in name:
              lowercase       :							Optional[int]									=				name.replace("module.mlp_head.0"	,					"classifier.layernorm"    )
       if "module.mlp_head.1" in name:
              lowercase       :							Any									=				name.replace("module.mlp_head.1"	,					"classifier.dense"    )

       return name


def     __magic_name__      ( __snake_case							:			str	,					__snake_case							:			Union[str, Any]    )					->							Union[str, Any]:
       for key in orig_state_dict.copy().keys():
              lowercase       :							Any									=				orig_state_dict.pop(__snake_case    )

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

       return orig_state_dict


def     __magic_name__      ( __snake_case							:			Optional[Any]    )					->							Optional[int]:
       lowercase       :							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(__snake_case	,					__snake_case    )


@torch.no_grad()
def     __magic_name__      ( __snake_case							:			List[Any]	,					__snake_case							:			Optional[int]	,					__snake_case							:			Optional[Any]=False    )					->							Any:
       lowercase       :							Optional[Any]									=				get_audio_spectrogram_transformer_config(__snake_case    )

       lowercase       :							List[str]									=				{
           "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
       lowercase       :							Dict									=				model_name_to_url[model_name]
       lowercase       :							List[Any]									=				torch.hub.load_state_dict_from_url(__snake_case	,					map_location="cpu"    )
       # remove some keys
       remove_keys(__snake_case    )
       # rename some keys
       lowercase       :							List[str]									=				convert_state_dict(__snake_case	,					__snake_case    )

       # load 🤗 model
       lowercase       :							int									=				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
       lowercase       :							List[Any]									=				-4.2_67_73_93 if "speech-commands" not in model_name else -6.84_59_78
       lowercase       :							List[Any]									=				4.5_68_99_74 if "speech-commands" not in model_name else 5.5_65_45_26
       lowercase       :							Tuple									=				1024 if "speech-commands" not in model_name else 128
       lowercase       :							Optional[int]									=				ASTFeatureExtractor(mean=__snake_case	,					std=__snake_case	,					max_length=__snake_case    )

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

              lowercase						,       lowercase       :							str									=				torchaudio.load(__snake_case    )
              lowercase       :							str									=				waveform.squeeze().numpy()

       lowercase       :							List[str]									=				feature_extractor(__snake_case	,					sampling_rate=1_6000	,					return_tensors="pt"    )

       # forward pass
       lowercase       :							Union[str, Any]									=				model(**__snake_case    )
       lowercase       :							Optional[int]									=				outputs.logits

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

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




"""simple docstring"""




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A     :			Optional[int]  						=			{
    """configuration_mgp_str""": ["""MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MgpstrConfig"""],
    """processing_mgp_str""": ["""MgpstrProcessor"""],
    """tokenization_mgp_str""": ["""MgpstrTokenizer"""],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _A     :			Any  						=			[
       """MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """MgpstrModel""",
       """MgpstrPreTrainedModel""",
       """MgpstrForSceneTextRecognition""",
   ]

if TYPE_CHECKING:
   from .configuration_mgp_str import MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP, MgpstrConfig
   from .processing_mgp_str import MgpstrProcessor
   from .tokenization_mgp_str import MgpstrTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mgp_str import (
          MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST,
          MgpstrForSceneTextRecognition,
          MgpstrModel,
          MgpstrPreTrainedModel,
      )
else:
   import sys

   _A     :			Tuple  						=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


