
"""simple docstring"""





import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
UpperCamelCase_       :    Union[str, Any]						      =			sys.version_info >= (3, 10)
def 				A_  (__a=None					, __a=None					):

					'''simple docstring'''





					return field(default_factory=lambda: default					, metadata=__a					)



@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					42
			snake_case						   =					42
			snake_case						   =					42
			snake_case						   =					42





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					42
			snake_case						   =					field(default="toto"  ,					metadata={"help": "help message"}   )





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					False
			snake_case						   =					True
			snake_case						   =					None





class __lowerCAmelCase					(       _lowercase   ):




			"""simple docstring"""







			snake_case						   =					"titi"
			snake_case						   =					"toto"





class __lowerCAmelCase					(       _lowercase   ):




			"""simple docstring"""







			snake_case						   =					"titi"
			snake_case						   =					"toto"
			snake_case						   =					42





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					"toto"




			def   lowerCamelCase__  (					self    :       Optional[int]						)   ->			Optional[int]:







								"""simple docstring"""
								A_								=    BasicEnum(self.foo						)





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					"toto"




			def   lowerCamelCase__  (					self    :       str						)   ->			str:







								"""simple docstring"""
								A_								=    MixedTypeEnum(self.foo						)





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					None
			snake_case						   =					field(default=_lowercase  ,					metadata={"help": "help message"}   )
			snake_case						   =					None
			snake_case						   =					list_field(default=[]   )
			snake_case						   =					list_field(default=[]   )





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					list_field(default=[]   )
			snake_case						   =					list_field(default=[1, 2, 3]   )
			snake_case						   =					list_field(default=["Hallo", "Bonjour", "Hello"]   )
			snake_case						   =					list_field(default=[0.1, 0.2, 0.3]   )





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					field()
			snake_case						   =					field()
			snake_case						   =					field()




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			Dict:







								"""simple docstring"""
								A_								=    BasicEnum(self.required_enum						)





@dataclass
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					42
			snake_case						   =					field()
			snake_case						   =					None
			snake_case						   =					field(default="toto"  ,					metadata={"help": "help message"}   )
			snake_case						   =					list_field(default=["Hallo", "Bonjour", "Hello"]   )


if is_python_no_less_than_3_10:



		@dataclass
		class __lowerCAmelCase					:




					"""simple docstring"""







					snake_case						   =					False
					snake_case						   =					True
					snake_case						   =					None





		@dataclass
		class __lowerCAmelCase					:




					"""simple docstring"""







					snake_case						   =					None
					snake_case						   =					field(default=_lowercase  ,					metadata={"help": "help message"}   )
					snake_case						   =					None
					snake_case						   =					list_field(default=[]   )
					snake_case						   =					list_field(default=[]   )




class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







			def   lowerCamelCase__  (					self    :       Dict							, _snake_case    :       argparse.ArgumentParser							, _snake_case    :       argparse.ArgumentParser						)   ->			Optional[int]:







								"""simple docstring"""
								self.assertEqual(len(a._actions						)							, len(b._actions						)						)
								for x, y in zip(a._actions							, b._actions						):
													A_								=    {k: v for k, v in vars(_snake_case						).items() if k != "container"}
													A_								=    {k: v for k, v in vars(_snake_case						).items() if k != "container"}

													# Choices with mixed type have custom function as "type"
													# So we need to compare results directly for equality
													if xx.get("choices"							, _snake_case						) and yy.get("choices"							, _snake_case						):
																		for expected_choice in yy["choices"] + xx["choices"]:
																							self.assertEqual(xx["type"](_snake_case						)							, yy["type"](_snake_case						)						)
																		del xx["type"], yy["type"]

													self.assertEqual(_snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       str						)   ->			List[Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument("--foo"							, type=_snake_case							, required=_snake_case						)
								expected.add_argument("--bar"							, type=_snake_case							, required=_snake_case						)
								expected.add_argument("--baz"							, type=_snake_case							, required=_snake_case						)
								expected.add_argument("--flag"							, type=_snake_case							, default=_snake_case							, const=_snake_case							, nargs="?"						)
								self.argparsersEqual(_snake_case							, _snake_case						)

								A_								=    ["--foo", "1", "--baz", "quux", "--bar", "0.5"]
								((A_)			,     )								=    parser.parse_args_into_dataclasses(_snake_case							, look_for_args_file=_snake_case						)
								self.assertFalse(example.flag						)




			def   lowerCamelCase__  (					self    :       Union[str, Any]						)   ->			Optional[Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument("--foo"							, default=42							, type=_snake_case						)
								expected.add_argument("--baz"							, default="toto"							, type=_snake_case							, help="help message"						)
								self.argparsersEqual(_snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       Any						)   ->			Optional[Any]:







								"""simple docstring"""
								A_								=    argparse.ArgumentParser()
								expected.add_argument("--foo"							, type=_snake_case							, default=_snake_case							, const=_snake_case							, nargs="?"						)
								expected.add_argument("--baz"							, type=_snake_case							, default=_snake_case							, const=_snake_case							, nargs="?"						)
								# A boolean no_* argument always has to come after its "default: True" regular counter-part
								# and its default must be set to False
								expected.add_argument("--no_baz"							, action="store_false"							, default=_snake_case							, dest="baz"						)
								expected.add_argument("--opt"							, type=_snake_case							, default=_snake_case						)

								A_								=    [WithDefaultBoolExample]
								if is_python_no_less_than_3_10:
													dataclass_types.append(_snake_case						)

								for dataclass_type in dataclass_types:
													A_								=    HfArgumentParser(_snake_case						)
													self.argparsersEqual(_snake_case							, _snake_case						)

													A_								=    parser.parse_args([]						)
													self.assertEqual(_snake_case							, Namespace(foo=_snake_case							, baz=_snake_case							, opt=_snake_case						)						)

													A_								=    parser.parse_args(["--foo", "--no_baz"]						)
													self.assertEqual(_snake_case							, Namespace(foo=_snake_case							, baz=_snake_case							, opt=_snake_case						)						)

													A_								=    parser.parse_args(["--foo", "--baz"]						)
													self.assertEqual(_snake_case							, Namespace(foo=_snake_case							, baz=_snake_case							, opt=_snake_case						)						)

													A_								=    parser.parse_args(["--foo", "True", "--baz", "True", "--opt", "True"]						)
													self.assertEqual(_snake_case							, Namespace(foo=_snake_case							, baz=_snake_case							, opt=_snake_case						)						)

													A_								=    parser.parse_args(["--foo", "False", "--baz", "False", "--opt", "False"]						)
													self.assertEqual(_snake_case							, Namespace(foo=_snake_case							, baz=_snake_case							, opt=_snake_case						)						)




			def   lowerCamelCase__  (					self    :       Optional[int]						)   ->			List[Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument(
								    "--foo"							, default="toto"							, choices=["titi", "toto", 42]							, type=make_choice_type_function(["titi", "toto", 42]						)							, )
								self.argparsersEqual(_snake_case							, _snake_case						)

								A_								=    parser.parse_args([]						)
								self.assertEqual(args.foo							, "toto"						)
								A_								=    parser.parse_args_into_dataclasses([]						)[0]
								self.assertEqual(enum_ex.foo							, MixedTypeEnum.toto						)

								A_								=    parser.parse_args(["--foo", "titi"]						)
								self.assertEqual(args.foo							, "titi"						)
								A_								=    parser.parse_args_into_dataclasses(["--foo", "titi"]						)[0]
								self.assertEqual(enum_ex.foo							, MixedTypeEnum.titi						)

								A_								=    parser.parse_args(["--foo", "42"]						)
								self.assertEqual(args.foo							, 42						)
								A_								=    parser.parse_args_into_dataclasses(["--foo", "42"]						)[0]
								self.assertEqual(enum_ex.foo							, MixedTypeEnum.fourtytwo						)




			def   lowerCamelCase__  (					self    :       Union[str, Any]						)   ->			List[str]:







								"""simple docstring"""



								@dataclass
								class __lowerCAmelCase					:




											"""simple docstring"""







											snake_case						   =					"toto"





								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument(
								    "--foo"							, default="toto"							, choices=("titi", "toto", 42)							, type=make_choice_type_function(["titi", "toto", 42]						)							, )
								self.argparsersEqual(_snake_case							, _snake_case						)

								A_								=    parser.parse_args([]						)
								self.assertEqual(args.foo							, "toto"						)

								A_								=    parser.parse_args(["--foo", "titi"]						)
								self.assertEqual(args.foo							, "titi"						)

								A_								=    parser.parse_args(["--foo", "42"]						)
								self.assertEqual(args.foo							, 42						)




			def   lowerCamelCase__  (					self    :       str						)   ->			Union[str, Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument("--foo_int"							, nargs="+"							, default=[]							, type=_snake_case						)
								expected.add_argument("--bar_int"							, nargs="+"							, default=[1, 2, 3]							, type=_snake_case						)
								expected.add_argument("--foo_str"							, nargs="+"							, default=["Hallo", "Bonjour", "Hello"]							, type=_snake_case						)
								expected.add_argument("--foo_float"							, nargs="+"							, default=[0.1, 0.2, 0.3]							, type=_snake_case						)

								self.argparsersEqual(_snake_case							, _snake_case						)

								A_								=    parser.parse_args([]						)
								self.assertEqual(
								    _snake_case							, Namespace(foo_int=[]							, bar_int=[1, 2, 3]							, foo_str=["Hallo", "Bonjour", "Hello"]							, foo_float=[0.1, 0.2, 0.3]						)							, )

								A_								=    parser.parse_args("--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7".split()						)
								self.assertEqual(_snake_case							, Namespace(foo_int=[1]							, bar_int=[2, 3]							, foo_str=["a", "b", "c"]							, foo_float=[0.1, 0.7]						)						)




			def   lowerCamelCase__  (					self    :       Union[str, Any]						)   ->			List[str]:







								"""simple docstring"""
								A_								=    argparse.ArgumentParser()
								expected.add_argument("--foo"							, default=_snake_case							, type=_snake_case						)
								expected.add_argument("--bar"							, default=_snake_case							, type=_snake_case							, help="help message"						)
								expected.add_argument("--baz"							, default=_snake_case							, type=_snake_case						)
								expected.add_argument("--ces"							, nargs="+"							, default=[]							, type=_snake_case						)
								expected.add_argument("--des"							, nargs="+"							, default=[]							, type=_snake_case						)

								A_								=    [OptionalExample]
								if is_python_no_less_than_3_10:
													dataclass_types.append(_snake_case						)

								for dataclass_type in dataclass_types:
													A_								=    HfArgumentParser(_snake_case						)

													self.argparsersEqual(_snake_case							, _snake_case						)

													A_								=    parser.parse_args([]						)
													self.assertEqual(_snake_case							, Namespace(foo=_snake_case							, bar=_snake_case							, baz=_snake_case							, ces=[]							, des=[]						)						)

													A_								=    parser.parse_args("--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3".split()						)
													self.assertEqual(_snake_case							, Namespace(foo=12							, bar=3.1_4							, baz="42"							, ces=["a", "b", "c"]							, des=[1, 2, 3]						)						)




			def   lowerCamelCase__  (					self    :       Any						)   ->			Dict:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument("--required_list"							, nargs="+"							, type=_snake_case							, required=_snake_case						)
								expected.add_argument("--required_str"							, type=_snake_case							, required=_snake_case						)
								expected.add_argument(
								    "--required_enum"							, type=make_choice_type_function(["titi", "toto"]						)							, choices=["titi", "toto"]							, required=_snake_case							, )
								self.argparsersEqual(_snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       Optional[int]						)   ->			Any:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    argparse.ArgumentParser()
								expected.add_argument("--foo"							, type=_snake_case							, required=_snake_case						)
								expected.add_argument(
								    "--required_enum"							, type=make_choice_type_function(["titi", "toto"]						)							, choices=["titi", "toto"]							, required=_snake_case							, )
								expected.add_argument("--opt"							, type=_snake_case							, default=_snake_case						)
								expected.add_argument("--baz"							, default="toto"							, type=_snake_case							, help="help message"						)
								expected.add_argument("--foo_str"							, nargs="+"							, default=["Hallo", "Bonjour", "Hello"]							, type=_snake_case						)
								self.argparsersEqual(_snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			Optional[Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    {
								    "foo": 12,
								    "bar": 3.1_4,
								    "baz": "42",
								    "flag": True,
								}

								A_								=    parser.parse_dict(_snake_case						)[0]
								A_								=    BasicExample(**_snake_case						)
								self.assertEqual(_snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       str						)   ->			Union[str, Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    {
								    "foo": 12,
								    "bar": 3.1_4,
								    "baz": "42",
								    "flag": True,
								    "extra": 42,
								}

								self.assertRaises(_snake_case							, parser.parse_dict							, _snake_case							, allow_extra_keys=_snake_case						)




			def   lowerCamelCase__  (					self    :       List[Any]						)   ->			List[Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    {
								    "foo": 12,
								    "bar": 3.1_4,
								    "baz": "42",
								    "flag": True,
								}
								with tempfile.TemporaryDirectory() as tmp_dir:
													A_								=    os.path.join(_snake_case							, "temp_json"						)
													os.mkdir(_snake_case						)
													with open(temp_local_path + ".json"							, "w+"						) as f:
																		json.dump(_snake_case							, _snake_case						)
													A_								=    parser.parse_yaml_file(Path(temp_local_path + ".json"						)						)[0]

								A_								=    BasicExample(**_snake_case						)
								self.assertEqual(_snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       Union[str, Any]						)   ->			Union[str, Any]:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)

								A_								=    {
								    "foo": 12,
								    "bar": 3.1_4,
								    "baz": "42",
								    "flag": True,
								}
								with tempfile.TemporaryDirectory() as tmp_dir:
													A_								=    os.path.join(_snake_case							, "temp_yaml"						)
													os.mkdir(_snake_case						)
													with open(temp_local_path + ".yaml"							, "w+"						) as f:
																		yaml.dump(_snake_case							, _snake_case						)
													A_								=    parser.parse_yaml_file(Path(temp_local_path + ".yaml"						)						)[0]
								A_								=    BasicExample(**_snake_case						)
								self.assertEqual(_snake_case							, _snake_case						)






			def   lowerCamelCase__  (					self    :       int						)   ->			int:







								"""simple docstring"""
								A_								=    HfArgumentParser(_snake_case						)
								self.assertIsNotNone(_snake_case						)






"""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_       :    Any						      =			logging.get_logger(__name__)
def 				A_  (__a					):

					'''simple docstring'''





					A_								=    ASTConfig()

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

					A_								=    "huggingface/label-files"
					if "speech-commands" in model_name:
										A_								=    35
										A_								=    "speech-commands-v2-id2label.json"
					else:
										A_								=    527
										A_								=    "audioset-id2label.json"

					A_								=    json.load(open(hf_hub_download(__a					, __a					, repo_type="dataset"					)					, "r"					)					)
					A_								=    {int(__a					): v for k, v in idalabel.items()}
					A_								=    idalabel
					A_								=    {v: k for k, v in idalabel.items()}

					return config
def 				A_  (__a					):

					'''simple docstring'''





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

					return name
def 				A_  (__a					, __a					):

					'''simple docstring'''





					for key in orig_state_dict.copy().keys():
										A_								=    orig_state_dict.pop(__a					)

										if "qkv" in key:
															A_								=    key.split("."					)
															A_								=    int(key_split[3]					)
															A_								=    config.hidden_size
															if "weight" in key:
																				A_								=    val[:dim, :]
																				A_								=    val[dim : dim * 2, :]
																				A_								=    val[-dim:, :]
															else:
																				A_								=    val[:dim]
																				A_								=    val[dim : dim * 2]
																				A_								=    val[-dim:]
										else:
															A_								=    val

					return orig_state_dict
def 				A_  (__a					):

					'''simple docstring'''





					A_								=    [
					    "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 				A_  (__a					, __a					, __a=False					):

					'''simple docstring'''





					A_								=    get_audio_spectrogram_transformer_config(__a					)

					A_								=    {
					    "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_								=    model_name_to_url[model_name]
					A_								=    torch.hub.load_state_dict_from_url(__a					, map_location="cpu"					)
					# remove some keys
					remove_keys(__a					)
					# rename some keys
					A_								=    convert_state_dict(__a					, __a					)

					# load 🤗 model
					A_								=    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
					A_								=    -4.2677393 if "speech-commands" not in model_name else -6.845978
					A_								=    4.5689974 if "speech-commands" not in model_name else 5.5654526
					A_								=    1024 if "speech-commands" not in model_name else 128
					A_								=    ASTFeatureExtractor(mean=__a					, std=__a					, max_length=__a					)

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

										A_			,     A_								=    torchaudio.load(__a					)
										A_								=    waveform.squeeze().numpy()

					A_								=    feature_extractor(__a					, sampling_rate=1_6000					, return_tensors="pt"					)

					# forward pass
					A_								=    model(**__a					)
					A_								=    outputs.logits

					if model_name == "ast-finetuned-audioset-10-10-0.4593":
										A_								=    torch.tensor([-0.8760, -7.0042, -8.6602]					)
					elif model_name == "ast-finetuned-audioset-10-10-0.450":
										A_								=    torch.tensor([-1.1986, -7.0903, -8.2718]					)
					elif model_name == "ast-finetuned-audioset-10-10-0.448":
										A_								=    torch.tensor([-2.6128, -8.0080, -9.4344]					)
					elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
										A_								=    torch.tensor([-1.5080, -7.4534, -8.8917]					)
					elif model_name == "ast-finetuned-audioset-12-12-0.447":
										A_								=    torch.tensor([-0.5050, -6.5833, -8.0843]					)
					elif model_name == "ast-finetuned-audioset-14-14-0.443":
										A_								=    torch.tensor([-0.3826, -7.0336, -8.2413]					)
					elif model_name == "ast-finetuned-audioset-16-16-0.442":
										A_								=    torch.tensor([-1.2113, -6.9101, -8.3470]					)
					elif model_name == "ast-finetuned-speech-commands-v2":
										A_								=    torch.tensor([6.1589, -8.0566, -8.7984]					)
					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_       :    Dict						      =			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[str]						      =			parser.parse_args()
		convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




