'''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()
SCREAMING_SNAKE_CASE_:     Optional[int]  =logging.get_logger(__name__)





def 	lowerCAmelCase_				(					snake_case_       : Any			)    ->      int:


     '''simple docstring'''




     UpperCAmelCase_           =   ASTConfig()

     if "10-10" in model_name:
          pass
     elif "speech-commands" in model_name:
          UpperCAmelCase_           =   1_28
     elif "12-12" in model_name:
          UpperCAmelCase_           =   12
          UpperCAmelCase_           =   12
     elif "14-14" in model_name:
          UpperCAmelCase_           =   14
          UpperCAmelCase_           =   14
     elif "16-16" in model_name:
          UpperCAmelCase_           =   16
          UpperCAmelCase_           =   16
     else:
          raise ValueError("Model not supported"			)

     UpperCAmelCase_           =   "huggingface/label-files"
     if "speech-commands" in model_name:
          UpperCAmelCase_           =   35
          UpperCAmelCase_           =   "speech-commands-v2-id2label.json"
     else:
          UpperCAmelCase_           =   5_27
          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 	lowerCAmelCase_				(					snake_case_       : List[str]			)    ->      Any:


     '''simple docstring'''




     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 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : Optional[Any]			)    ->      Union[str, Any]:


     '''simple docstring'''




     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 	lowerCAmelCase_				(					snake_case_       : Any			)    ->      str:


     '''simple docstring'''




     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 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : Any					,    snake_case_       : Optional[int]=False			)    ->      List[Any]:


     '''simple docstring'''




     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.267_7393 if "speech-commands" not in model_name else -6.84_5978
     UpperCAmelCase_           =   4.568_9974 if "speech-commands" not in model_name else 5.565_4526
     UpperCAmelCase_           =   10_24 if "speech-commands" not in model_name else 1_28
     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_60_00					,    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.8760, -7.0042, -8.6602]			)
     elif model_name == "ast-finetuned-audioset-10-10-0.450":
          UpperCAmelCase_           =   torch.tensor([-1.1986, -7.0903, -8.2718]			)
     elif model_name == "ast-finetuned-audioset-10-10-0.448":
          UpperCAmelCase_           =   torch.tensor([-2.6128, -8.0080, -9.4344]			)
     elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
          UpperCAmelCase_           =   torch.tensor([-1.5080, -7.4534, -8.8917]			)
     elif model_name == "ast-finetuned-audioset-12-12-0.447":
          UpperCAmelCase_           =   torch.tensor([-0.5050, -6.5833, -8.0843]			)
     elif model_name == "ast-finetuned-audioset-14-14-0.443":
          UpperCAmelCase_           =   torch.tensor([-0.3826, -7.0336, -8.2413]			)
     elif model_name == "ast-finetuned-audioset-16-16-0.442":
          UpperCAmelCase_           =   torch.tensor([-1.2113, -6.9101, -8.3470]			)
     elif model_name == "ast-finetuned-speech-commands-v2":
          UpperCAmelCase_           =   torch.tensor([6.1589, -8.0566, -8.7984]			)
     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__":
    SCREAMING_SNAKE_CASE_:     Tuple  =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.'
    )

    SCREAMING_SNAKE_CASE_:     List[Any]  =parser.parse_args()
    convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











from heapq import heappop, heappush

import numpy as np







def  _SCREAMING_SNAKE_CASE				(   a					,						a					,						a					,						a					,						)      ->      tuple[float | int, list[tuple[int, int]]]:
					__A    ,				__A	:						int       =				grid.shape
					__A	:						Any       =				[-1, 1, 0, 0]
					__A	:						Optional[Any]       =				[0, 0, -1, 1]
					if allow_diagonal:
										dx += [-1, -1, 1, 1]
										dy += [-1, 1, -1, 1]

					__A    ,				__A	:						Optional[int]       =				[(0, source)], set()
					__A	:						Any       =				np.full((rows, cols)					,						np.inf  )
					__A	:						Any       =				0
					__A	:						Any       =				np.empty((rows, cols)					,						dtype=a  )
					__A	:						Optional[Any]       =				None

					while queue:
										((__A)    ,				(__A))	:						List[str]       =				heappop(a  )
										if (x, y) in visited:
															continue
										visited.add((x, y)  )

										if (x, y) == destination:
															__A	:						int       =				[]
															while (x, y) != source:
																				path.append((x, y)  )
																				__A    ,				__A	:						Optional[int]       =				predecessors[x, y]
															path.append(a  )  # add the source manually
															path.reverse()
															return matrix[destination], path

										for i in range(len(a  )  ):
															__A    ,				__A	:						Union[str, Any]       =				x + dx[i], y + dy[i]
															if 0 <= nx < rows and 0 <= ny < cols:
																				__A	:						Optional[int]       =				grid[nx][ny]
																				if next_node == 1 and matrix[nx, ny] > dist + 1:
																									heappush(a					,						(dist + 1, (nx, ny))  )
																									__A	:						List[Any]       =				dist + 1
																									__A	:						Union[str, Any]       =				(x, y)

					return np.inf, []


if __name__ == "__main__":
				import doctest

				doctest.testmod()




