



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_										=					logging.get_logger(__name__)







def 	lowerCamelCase_   (  _a    :		int  ):



    '''simple docstring'''




    UpperCAmelCase_			:    Optional[Any]   						= ASTConfig()

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

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

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

    return config







def 	lowerCamelCase_   (  _a    :		str  ):



    '''simple docstring'''




    if "module.v" in name:
        UpperCAmelCase_			:    Dict   						= name.replace("""module.v"""					,						"""audio_spectrogram_transformer"""  )
    if "cls_token" in name:
        UpperCAmelCase_			:    List[Any]   						= name.replace("""cls_token"""					,						"""embeddings.cls_token"""  )
    if "dist_token" in name:
        UpperCAmelCase_			:    Dict   						= name.replace("""dist_token"""					,						"""embeddings.distillation_token"""  )
    if "pos_embed" in name:
        UpperCAmelCase_			:    List[str]   						= name.replace("""pos_embed"""					,						"""embeddings.position_embeddings"""  )
    if "patch_embed.proj" in name:
        UpperCAmelCase_			:    List[str]   						= 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_			:    Optional[int]   						= name.replace("""attn.proj"""					,						"""attention.output.dense"""  )
    if "attn" in name:
        UpperCAmelCase_			:    Any   						= name.replace("""attn"""					,						"""attention.self"""  )
    if "norm1" in name:
        UpperCAmelCase_			:    str   						= name.replace("""norm1"""					,						"""layernorm_before"""  )
    if "norm2" in name:
        UpperCAmelCase_			:    Tuple   						= name.replace("""norm2"""					,						"""layernorm_after"""  )
    if "mlp.fc1" in name:
        UpperCAmelCase_			:    List[str]   						= name.replace("""mlp.fc1"""					,						"""intermediate.dense"""  )
    if "mlp.fc2" in name:
        UpperCAmelCase_			:    Union[str, Any]   						= 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_			:    int   						= name.replace("""module.mlp_head.0"""					,						"""classifier.layernorm"""  )
    if "module.mlp_head.1" in name:
        UpperCAmelCase_			:    Dict   						= name.replace("""module.mlp_head.1"""					,						"""classifier.dense"""  )

    return name







def 	lowerCamelCase_   (  _a    :		Any					,						_a    :		Dict  ):



    '''simple docstring'''




    for key in orig_state_dict.copy().keys():
        UpperCAmelCase_			:    Optional[Any]   						= orig_state_dict.pop(SCREAMING_SNAKE_CASE_  )

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

    return orig_state_dict







def 	lowerCamelCase_   (  _a    :		int  ):



    '''simple docstring'''




    UpperCAmelCase_			:    Optional[Any]   						= [
        """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(SCREAMING_SNAKE_CASE_					,						SCREAMING_SNAKE_CASE_  )







@torch.no_grad()
def 	lowerCamelCase_   (  _a    :		int					,						_a    :		List[Any]					,						_a    :		Union[str, Any]=False  ):



    '''simple docstring'''




    UpperCAmelCase_			:    Optional[int]   						= get_audio_spectrogram_transformer_config(SCREAMING_SNAKE_CASE_  )

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

    # load 🤗 model
    UpperCAmelCase_			:    Any   						= ASTForAudioClassification(SCREAMING_SNAKE_CASE_  )
    model.eval()

    model.load_state_dict(SCREAMING_SNAKE_CASE_  )

    # verify outputs on dummy input
    # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
    UpperCAmelCase_			:    Optional[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_			:    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_			:    Union[str, Any]   						= 1024 if """speech-commands""" not in model_name else 128
    UpperCAmelCase_			:    Dict   						= ASTFeatureExtractor(mean=SCREAMING_SNAKE_CASE_					,						std=SCREAMING_SNAKE_CASE_					,						max_length=SCREAMING_SNAKE_CASE_  )

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

        UpperCAmelCase_						,      UpperCAmelCase_			:    List[Any]   						= torchaudio.load(SCREAMING_SNAKE_CASE_  )
        UpperCAmelCase_			:    Any   						= waveform.squeeze().numpy()

    UpperCAmelCase_			:    int   						= feature_extractor(SCREAMING_SNAKE_CASE_					,						sampling_rate=1_6000					,						return_tensors="""pt"""  )

    # forward pass
    UpperCAmelCase_			:    List[Any]   						= model(**SCREAMING_SNAKE_CASE_  )
    UpperCAmelCase_			:    Optional[Any]   						= outputs.logits

    if model_name == "ast-finetuned-audioset-10-10-0.4593":
        UpperCAmelCase_			:    int   						= 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_			:    Dict   						= 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_			:    Tuple   						= 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_			:    List[Any]   						= 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_			:    Dict   						= 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]					,						SCREAMING_SNAKE_CASE_					,						atol=1E-4  ):
        raise ValueError("""Logits don\'t match"""  )
    print("""Looks ok!"""  )

    if pytorch_dump_folder_path is not None:
        Path(SCREAMING_SNAKE_CASE_  ).mkdir(exist_ok=SCREAMING_SNAKE_CASE_  )
        print(F'''Saving model {model_name} to {pytorch_dump_folder_path}'''  )
        model.save_pretrained(SCREAMING_SNAKE_CASE_  )
        print(F'''Saving feature extractor to {pytorch_dump_folder_path}'''  )
        feature_extractor.save_pretrained(SCREAMING_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__":
      UpperCamelCase_										=					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_										=					parser.parse_args()
      convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




"""simple docstring"""




__UpperCamelCase						=      0  # The first color of the flag.
__UpperCamelCase						=      1  # The second color of the flag.
__UpperCamelCase						=      2  # The third color of the flag.
__UpperCamelCase						=      (red, white, blue)


def     lowercase			(SCREAMING_SNAKE_CASE_		:				list  )   ->						list:
						if not sequence:
												return []
						if len(SCREAMING_SNAKE_CASE_  ) == 1:
												return list(SCREAMING_SNAKE_CASE_  )
						SCREAMING_SNAKE_CASE													=					0
						SCREAMING_SNAKE_CASE													=					len(SCREAMING_SNAKE_CASE_  ) - 1
						SCREAMING_SNAKE_CASE													=					0
						while mid <= high:
												if sequence[mid] == colors[0]:
																		SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					sequence[mid], sequence[low]
																		low += 1
																		mid += 1
												elif sequence[mid] == colors[1]:
																		mid += 1
												elif sequence[mid] == colors[2]:
																		SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					sequence[high], sequence[mid]
																		high -= 1
												else:
																		SCREAMING_SNAKE_CASE													=					F'The elements inside the sequence must contains only {colors} values'
																		raise ValueError(SCREAMING_SNAKE_CASE_  )
						return sequence


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	__UpperCamelCase						=      input('''Enter numbers separated by commas:\n''').strip()
	__UpperCamelCase						=      [int(item.strip()) for item in user_input.split(''',''')]
	print(f'''{dutch_national_flag_sort(unsorted)}''')


