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







def        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[int] )				->       Optional[Any]:





  """simple docstring"""

  __A		:     List[str]												=		ASTConfig()

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

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

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

  return config







def        A_     (						__SCREAMING_SNAKE_CASE						:  Any )				->       Optional[int]:





  """simple docstring"""

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

  return name







def        A_     (						__SCREAMING_SNAKE_CASE						:  int			,     __SCREAMING_SNAKE_CASE						:  Optional[Any] )				->       Any:





  """simple docstring"""

  for key in orig_state_dict.copy().keys():
    __A		:     str												=		orig_state_dict.pop(_lowerCamelCase )

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

  return orig_state_dict







def        A_     (						__SCREAMING_SNAKE_CASE						:  str )				->       Dict:





  """simple docstring"""

  __A		:     Dict												=		[
      "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        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[int]			,     __SCREAMING_SNAKE_CASE						:  Dict			,     __SCREAMING_SNAKE_CASE						:  Optional[Any]=False )				->       Tuple:





  """simple docstring"""

  __A		:     Optional[Any]												=		get_audio_spectrogram_transformer_config(_lowerCamelCase )

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

  # load 🤗 model
  __A		:     Dict												=		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
  __A		:     Union[str, Any]												=		-4.2_677_393 if "speech-commands" not in model_name else -6.845_978
  __A		:     Optional[Any]												=		4.5_689_974 if "speech-commands" not in model_name else 5.5_654_526
  __A		:     List[str]												=		1024 if "speech-commands" not in model_name else 128
  __A		:     Optional[int]												=		ASTFeatureExtractor(mean=_lowerCamelCase			,     std=_lowerCamelCase			,     max_length=_lowerCamelCase )

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

    __A		:     Any												=		torchaudio.load(_lowerCamelCase )
    __A		:     Union[str, Any]												=		waveform.squeeze().numpy()

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

  # forward pass
  __A		:     str												=		model(**_lowerCamelCase )
  __A		:     str												=		outputs.logits

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

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





'''simple docstring'''
from collections.abc import Sequence







def        A_     (						__SCREAMING_SNAKE_CASE						:  Sequence[float]			,     __SCREAMING_SNAKE_CASE						:  bool = False )				->       float:





  """simple docstring"""

  if not arr:
    return 0

  __A		:     Any												=		0 if allow_empty_subarrays else float("""-inf""" )
  __A		:     List[Any]												=		0.0
  for num in arr:
    __A		:     Tuple												=		max(0 if allow_empty_subarrays else num			,     curr_sum + num )
    __A		:     Optional[int]												=		max(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )

  return max_sum


if __name__ == "__main__":
     from doctest import testmod

     testmod()

     A__   :		Any 		=[-2, 1, -3, 4, -1, 2, 1, -5, 4]
     print(F"{max_subarray_sum(nums) = }")



