

'''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[Any]  =logging.get_logger(__name__)





def      lowerCAmelCase_    ( snake_case_	:			List[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(lowerCAmelCase__ ,   lowerCAmelCase__ ,   repo_type="dataset"      ) ,   "r"      )      )
     UpperCAmelCase_	   =       {int(lowerCAmelCase__      ): v for k, v in idalabel.items()}
     UpperCAmelCase_	   =       idalabel
     UpperCAmelCase_	   =       {v: k for k, v in idalabel.items()}

     return config





def      lowerCAmelCase_    ( snake_case_	:			Dict      )   ->				Tuple:


     '''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_	:			str ,   snake_case_	:			List[str]      )   ->				Union[str, Any]:


     '''simple docstring'''




     for key in orig_state_dict.copy().keys():
          UpperCAmelCase_	   =       orig_state_dict.pop(lowerCAmelCase__      )

          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_	:			Optional[Any]      )   ->				Dict:


     '''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(lowerCAmelCase__ ,   lowerCAmelCase__      )





@torch.no_grad()
def      lowerCAmelCase_    ( snake_case_	:			Dict ,   snake_case_	:			List[Any] ,   snake_case_	:			Any=False      )   ->				Optional[int]:


     '''simple docstring'''




     UpperCAmelCase_	   =       get_audio_spectrogram_transformer_config(lowerCAmelCase__      )

     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(lowerCAmelCase__ ,   map_location="cpu"      )
     # remove some keys
     remove_keys(lowerCAmelCase__      )
     # rename some keys
     UpperCAmelCase_	   =       convert_state_dict(lowerCAmelCase__ ,   lowerCAmelCase__      )

     # load 🤗 model
     UpperCAmelCase_	   =       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_	   =       -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=lowerCAmelCase__ ,   std=lowerCAmelCase__ ,   max_length=lowerCAmelCase__      )

     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(lowerCAmelCase__      )
          UpperCAmelCase_	   =       waveform.squeeze().numpy()

     UpperCAmelCase_	   =       feature_extractor(lowerCAmelCase__ ,   sampling_rate=1_60_00 ,   return_tensors="pt"      )

     # forward pass
     UpperCAmelCase_	   =       model(**lowerCAmelCase__      )
     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] ,   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__":
    SCREAMING_SNAKE_CASE_:					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.'
    )

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





'''simple docstring'''





def      lowerCAmelCase_    ( snake_case_	:			int = 1_00_00_00      )   ->				int:


     '''simple docstring'''




     UpperCAmelCase_	   =       limit + 1
     UpperCAmelCase_	   =       [0] * limit
     for first_term in range(1 ,   snake_case_      ):
          for n in range(snake_case_ ,   snake_case_ ,   snake_case_      ):
               UpperCAmelCase_	   =       first_term + n / first_term
               if common_difference % 4:  # d must be divisble by 4
                    continue
               else:
                    common_difference /= 4
                    if (
                        first_term > common_difference
                        and first_term < 4 * common_difference
                    ):  # since x,y,z are positive integers
                         frequency[n] += 1  # so z>0 and a>d ,also 4d<a

     UpperCAmelCase_	   =       sum(1 for x in frequency[1:limit] if x == 10      )

     return count


if __name__ == "__main__":
    print(f"{solution() = }")




