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







def __UpperCamelCase(   _A					:				Union[str, Any]    ):
   '''simple docstring'''
   UpperCAmelCase__							:				int   				=  ASTConfig()

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

   UpperCAmelCase__							:				Any   				=  '''huggingface/label-files'''
   if "speech-commands" in model_name:
      UpperCAmelCase__							:				List[Any]   				=  35
      UpperCAmelCase__							:				str   				=  '''speech-commands-v2-id2label.json'''
   else:
      UpperCAmelCase__							:				Dict   				=  5_27
      UpperCAmelCase__							:				Any   				=  '''audioset-id2label.json'''

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

   return config







def __UpperCamelCase(   _A					:				List[str]    ):
   '''simple docstring'''
   if "module.v" in name:
      UpperCAmelCase__							:				str   				=  name.replace('''module.v'''  ,			'''audio_spectrogram_transformer'''    )
   if "cls_token" in name:
      UpperCAmelCase__							:				Optional[int]   				=  name.replace('''cls_token'''  ,			'''embeddings.cls_token'''    )
   if "dist_token" in name:
      UpperCAmelCase__							:				List[Any]   				=  name.replace('''dist_token'''  ,			'''embeddings.distillation_token'''    )
   if "pos_embed" in name:
      UpperCAmelCase__							:				Tuple   				=  name.replace('''pos_embed'''  ,			'''embeddings.position_embeddings'''    )
   if "patch_embed.proj" in name:
      UpperCAmelCase__							:				Union[str, Any]   				=  name.replace('''patch_embed.proj'''  ,			'''embeddings.patch_embeddings.projection'''    )
   # transformer blocks
   if "blocks" in name:
      UpperCAmelCase__							:				Optional[int]   				=  name.replace('''blocks'''  ,			'''encoder.layer'''    )
   if "attn.proj" in name:
      UpperCAmelCase__							:				Dict   				=  name.replace('''attn.proj'''  ,			'''attention.output.dense'''    )
   if "attn" in name:
      UpperCAmelCase__							:				Tuple   				=  name.replace('''attn'''  ,			'''attention.self'''    )
   if "norm1" in name:
      UpperCAmelCase__							:				List[Any]   				=  name.replace('''norm1'''  ,			'''layernorm_before'''    )
   if "norm2" in name:
      UpperCAmelCase__							:				Tuple   				=  name.replace('''norm2'''  ,			'''layernorm_after'''    )
   if "mlp.fc1" in name:
      UpperCAmelCase__							:				Tuple   				=  name.replace('''mlp.fc1'''  ,			'''intermediate.dense'''    )
   if "mlp.fc2" in name:
      UpperCAmelCase__							:				Optional[int]   				=  name.replace('''mlp.fc2'''  ,			'''output.dense'''    )
   # final layernorm
   if "audio_spectrogram_transformer.norm" in name:
      UpperCAmelCase__							:				Union[str, Any]   				=  name.replace('''audio_spectrogram_transformer.norm'''  ,			'''audio_spectrogram_transformer.layernorm'''    )
   # classifier head
   if "module.mlp_head.0" in name:
      UpperCAmelCase__							:				Any   				=  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 __UpperCamelCase(   _A					:				Optional[int]  ,			_A					:				Dict    ):
   '''simple docstring'''
   for key in orig_state_dict.copy().keys():
      UpperCAmelCase__							:				List[str]   				=  orig_state_dict.pop(_A    )

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

   return orig_state_dict







def __UpperCamelCase(   _A					:				Dict    ):
   '''simple docstring'''
   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(_A  ,			_A    )







@torch.no_grad()
def __UpperCamelCase(   _A					:				Union[str, Any]  ,			_A					:				List[Any]  ,			_A					:				Union[str, Any]=False    ):
   '''simple docstring'''
   UpperCAmelCase__							:				Any   				=  get_audio_spectrogram_transformer_config(_A    )

   UpperCAmelCase__							:				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
   UpperCAmelCase__							:				Tuple   				=  model_name_to_url[model_name]
   UpperCAmelCase__							:				int   				=  torch.hub.load_state_dict_from_url(_A  ,			map_location='''cpu'''    )
   # remove some keys
   remove_keys(_A    )
   # rename some keys
   UpperCAmelCase__							:				Tuple   				=  convert_state_dict(_A  ,			_A    )

   # load 🤗 model
   UpperCAmelCase__							:				List[str]   				=  ASTForAudioClassification(_A    )
   model.eval()

   model.load_state_dict(_A    )

   # verify outputs on dummy input
   # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
   UpperCAmelCase__							:				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__							:				Union[str, 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__							:				str   				=  10_24 if '''speech-commands''' not in model_name else 1_28
   UpperCAmelCase__							:				Dict   				=  ASTFeatureExtractor(mean=_A  ,			std=_A  ,			max_length=_A    )

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

      UpperCAmelCase__				,      UpperCAmelCase__							:				Dict   				=  torchaudio.load(_A    )
      UpperCAmelCase__							:				int   				=  waveform.squeeze().numpy()

   UpperCAmelCase__							:				Dict   				=  feature_extractor(_A  ,			sampling_rate=1_60_00  ,			return_tensors='''pt'''    )

   # forward pass
   UpperCAmelCase__							:				Union[str, Any]   				=  model(**_A    )
   UpperCAmelCase__							:				List[str]   				=  outputs.logits

   if model_name == "ast-finetuned-audioset-10-10-0.4593":
      UpperCAmelCase__							:				List[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__							:				str   				=  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__							:				Optional[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__							:				Optional[int]   				=  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__							:				Dict   				=  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__							:				Union[str, 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__							:				Dict   				=  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]  ,			_A  ,			atol=1e-4    ):
      raise ValueError('''Logits don\'t match'''    )
   print('''Looks ok!'''    )

   if pytorch_dump_folder_path is not None:
      Path(_A    ).mkdir(exist_ok=_A    )
      print(F'''Saving model {model_name} to {pytorch_dump_folder_path}'''    )
      model.save_pretrained(_A    )
      print(F'''Saving feature extractor to {pytorch_dump_folder_path}'''    )
      feature_extractor.save_pretrained(_A    )

   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__":
  UpperCamelCase__     :	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.'
  )

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





'''simple docstring'''

# Logistic Regression from scratch

# In[62]:

# In[63]:

# importing all the required libraries

import numpy as np
from matplotlib import pyplot as plt
from sklearn import datasets







def __UpperCamelCase(   _A					:				str    ):
   '''simple docstring'''
   return 1 / (1 + np.exp(-z    ))







def __UpperCamelCase(   _A					:				int  ,			_A					:				str    ):
   '''simple docstring'''
   return (-y * np.log(_A    ) - (1 - y) * np.log(1 - h    )).mean()







def __UpperCamelCase(   _A					:				Optional[Any]  ,			_A					:				Tuple  ,			_A					:				Any    ):
   '''simple docstring'''
   UpperCAmelCase__							:				Union[str, Any]   				=  np.dot(_A  ,			_A    )
   return np.sum(y * scores - np.log(1 + np.exp(_A    )    )    )







def __UpperCamelCase(   _A					:				Dict  ,			_A					:				Optional[int]  ,			_A					:				List[Any]  ,			_A					:				str=7_00_00    ):
   '''simple docstring'''
   UpperCAmelCase__							:				List[Any]   				=  np.zeros(x.shape[1]    )

   for iterations in range(_A    ):
      UpperCAmelCase__							:				Tuple   				=  np.dot(_A  ,			_A    )
      UpperCAmelCase__							:				Optional[Any]   				=  sigmoid_function(_A    )
      UpperCAmelCase__							:				Optional[int]   				=  np.dot(x.T  ,			h - y    ) / y.size
      UpperCAmelCase__							:				List[Any]   				=  theta - alpha * gradient  # updating the weights
      UpperCAmelCase__							:				Tuple   				=  np.dot(_A  ,			_A    )
      UpperCAmelCase__							:				Tuple   				=  sigmoid_function(_A    )
      UpperCAmelCase__							:				Optional[int]   				=  cost_function(_A  ,			_A    )
      if iterations % 1_00 == 0:
         print(F'''loss: {j} \t'''    )  # printing the loss after every 100 iterations
   return theta


# In[68]:

if __name__ == "__main__":
  UpperCamelCase__     :	str				=			datasets.load_iris()
  UpperCamelCase__     :	Tuple				=			iris.data[:, :2]
  UpperCamelCase__     :	str				=			(iris.target != 0) * 1

  UpperCamelCase__     :	Any				=			0.1
  UpperCamelCase__     :	List[str]				=			logistic_reg(alpha, x, y, max_iterations=70_000)
  print('theta: ', theta)  # printing the theta i.e our weights vector







  def __UpperCamelCase(   _A					:				Any    ):
     '''simple docstring'''
     return sigmoid_function(
         np.dot(_A  ,			_A    )    )  # predicting the value of probability from the logistic regression algorithm

  plt.figure(figsize=(10, 6))
  plt.scatter(x[y == 0][:, 0], x[y == 0][:, 1], color='b', label='0')
  plt.scatter(x[y == 1][:, 0], x[y == 1][:, 1], color='r', label='1')
  ((UpperCamelCase__)				,     (UpperCamelCase__))     :	Any				=			(x[:, 0].min(), x[:, 0].max())
  ((UpperCamelCase__)				,     (UpperCamelCase__))     :	Optional[Any]				=			(x[:, 1].min(), x[:, 1].max())
  ((UpperCamelCase__)				,     (UpperCamelCase__))     :	Any				=			np.meshgrid(np.linspace(xa_min, xa_max), np.linspace(xa_min, xa_max))
  UpperCamelCase__     :	str				=			np.c_[xxa.ravel(), xxa.ravel()]
  UpperCamelCase__     :	Union[str, Any]				=			predict_prob(grid).reshape(xxa.shape)
  plt.contour(xxa, xxa, probs, [0.5], linewidths=1, colors='black')

  plt.legend()
  plt.show()




