


'''simple docstring'''



import argparse
from collections import OrderedDict
from pathlib import Path

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision.transforms import functional as F

from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection
from transformers.utils import logging


logging.set_verbosity_info()
A__						:   Any				=    logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
A__						:   Optional[Any]				=    []
for i in range(6):
      # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
      rename_keys.append(
          (f'''transformer.encoder.layers.{i}.self_attn.out_proj.weight''', f'''encoder.layers.{i}.self_attn.out_proj.weight''')
      )
      rename_keys.append(
          (f'''transformer.encoder.layers.{i}.self_attn.out_proj.bias''', f'''encoder.layers.{i}.self_attn.out_proj.bias''')
      )
      rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.weight''', f'''encoder.layers.{i}.fc1.weight'''))
      rename_keys.append((f'''transformer.encoder.layers.{i}.linear1.bias''', f'''encoder.layers.{i}.fc1.bias'''))
      rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.weight''', f'''encoder.layers.{i}.fc2.weight'''))
      rename_keys.append((f'''transformer.encoder.layers.{i}.linear2.bias''', f'''encoder.layers.{i}.fc2.bias'''))
      rename_keys.append(
          (f'''transformer.encoder.layers.{i}.norm1.weight''', f'''encoder.layers.{i}.self_attn_layer_norm.weight''')
      )
      rename_keys.append((f'''transformer.encoder.layers.{i}.norm1.bias''', f'''encoder.layers.{i}.self_attn_layer_norm.bias'''))
      rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.weight''', f'''encoder.layers.{i}.final_layer_norm.weight'''))
      rename_keys.append((f'''transformer.encoder.layers.{i}.norm2.bias''', f'''encoder.layers.{i}.final_layer_norm.bias'''))
      # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
      rename_keys.append(
          (f'''transformer.decoder.layers.{i}.self_attn.out_proj.weight''', f'''decoder.layers.{i}.self_attn.out_proj.weight''')
      )
      rename_keys.append(
          (f'''transformer.decoder.layers.{i}.self_attn.out_proj.bias''', f'''decoder.layers.{i}.self_attn.out_proj.bias''')
      )
      rename_keys.append(
          (
              f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.weight''',
              f'''decoder.layers.{i}.encoder_attn.out_proj.weight''',
          )
      )
      rename_keys.append(
          (
              f'''transformer.decoder.layers.{i}.multihead_attn.out_proj.bias''',
              f'''decoder.layers.{i}.encoder_attn.out_proj.bias''',
          )
      )
      rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.weight''', f'''decoder.layers.{i}.fc1.weight'''))
      rename_keys.append((f'''transformer.decoder.layers.{i}.linear1.bias''', f'''decoder.layers.{i}.fc1.bias'''))
      rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.weight''', f'''decoder.layers.{i}.fc2.weight'''))
      rename_keys.append((f'''transformer.decoder.layers.{i}.linear2.bias''', f'''decoder.layers.{i}.fc2.bias'''))
      rename_keys.append(
          (f'''transformer.decoder.layers.{i}.norm1.weight''', f'''decoder.layers.{i}.self_attn_layer_norm.weight''')
      )
      rename_keys.append((f'''transformer.decoder.layers.{i}.norm1.bias''', f'''decoder.layers.{i}.self_attn_layer_norm.bias'''))
      rename_keys.append(
          (f'''transformer.decoder.layers.{i}.norm2.weight''', f'''decoder.layers.{i}.encoder_attn_layer_norm.weight''')
      )
      rename_keys.append(
          (f'''transformer.decoder.layers.{i}.norm2.bias''', f'''decoder.layers.{i}.encoder_attn_layer_norm.bias''')
      )
      rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.weight''', f'''decoder.layers.{i}.final_layer_norm.weight'''))
      rename_keys.append((f'''transformer.decoder.layers.{i}.norm3.bias''', f'''decoder.layers.{i}.final_layer_norm.bias'''))

# convolutional projection + query embeddings + layernorm of encoder + layernorm of decoder + class and bounding box heads
rename_keys.extend(
    [
        ("""input_proj.weight""", """input_projection.weight"""),
        ("""input_proj.bias""", """input_projection.bias"""),
        ("""query_embed.weight""", """query_position_embeddings.weight"""),
        ("""transformer.encoder.norm.weight""", """encoder.layernorm.weight"""),
        ("""transformer.encoder.norm.bias""", """encoder.layernorm.bias"""),
        ("""transformer.decoder.norm.weight""", """decoder.layernorm.weight"""),
        ("""transformer.decoder.norm.bias""", """decoder.layernorm.bias"""),
        ("""class_embed.weight""", """class_labels_classifier.weight"""),
        ("""class_embed.bias""", """class_labels_classifier.bias"""),
        ("""bbox_embed.layers.0.weight""", """bbox_predictor.layers.0.weight"""),
        ("""bbox_embed.layers.0.bias""", """bbox_predictor.layers.0.bias"""),
        ("""bbox_embed.layers.1.weight""", """bbox_predictor.layers.1.weight"""),
        ("""bbox_embed.layers.1.bias""", """bbox_predictor.layers.1.bias"""),
        ("""bbox_embed.layers.2.weight""", """bbox_predictor.layers.2.weight"""),
        ("""bbox_embed.layers.2.bias""", """bbox_predictor.layers.2.bias"""),
    ]
)



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							List[Any] ,       UpperCAmelCase_       :							List[Any]				)	->						Tuple:
     __lowerCamelCase  :      Optional[int]														=						state_dict.pop(__a				)
     __lowerCamelCase  :      str														=						val



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int				)	->						List[str]:
     __lowerCamelCase  :      str														=						OrderedDict()
     for key, value in state_dict.items():
          if "backbone.0.body" in key:
               __lowerCamelCase  :      List[str]														=						key.replace('backbone.0.body' ,       'backbone.conv_encoder.model'				)
               __lowerCamelCase  :      Any														=						value
          else:
               __lowerCamelCase  :      Any														=						value

     return new_state_dict



def      UpperCAmelCase__   (      UpperCAmelCase_       :							str				)	->						Optional[Any]:
     __lowerCamelCase  :      Any														=						''

     # first: transformer encoder
     for i in range(6				):
          # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
          __lowerCamelCase  :      Dict														=						state_dict.pop(F'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'				)
          __lowerCamelCase  :      List[Any]														=						state_dict.pop(F'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'				)
          # next, add query, keys and values (in that order) to the state dict
          __lowerCamelCase  :      Dict														=						in_proj_weight[:2_56, :]
          __lowerCamelCase  :      int														=						in_proj_bias[:2_56]
          __lowerCamelCase  :      Dict														=						in_proj_weight[2_56:5_12, :]
          __lowerCamelCase  :      Tuple														=						in_proj_bias[2_56:5_12]
          __lowerCamelCase  :      List[Any]														=						in_proj_weight[-2_56:, :]
          __lowerCamelCase  :      List[Any]														=						in_proj_bias[-2_56:]
     # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
     for i in range(6				):
          # read in weights + bias of input projection layer of self-attention
          __lowerCamelCase  :      int														=						state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'				)
          __lowerCamelCase  :      Tuple														=						state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'				)
          # next, add query, keys and values (in that order) to the state dict
          __lowerCamelCase  :      Union[str, Any]														=						in_proj_weight[:2_56, :]
          __lowerCamelCase  :      Union[str, Any]														=						in_proj_bias[:2_56]
          __lowerCamelCase  :      List[Any]														=						in_proj_weight[2_56:5_12, :]
          __lowerCamelCase  :      Union[str, Any]														=						in_proj_bias[2_56:5_12]
          __lowerCamelCase  :      Tuple														=						in_proj_weight[-2_56:, :]
          __lowerCamelCase  :      int														=						in_proj_bias[-2_56:]
          # read in weights + bias of input projection layer of cross-attention
          __lowerCamelCase  :      Tuple														=						state_dict.pop(
              F'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'				)
          __lowerCamelCase  :      Tuple														=						state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'				)
          # next, add query, keys and values (in that order) of cross-attention to the state dict
          __lowerCamelCase  :      Union[str, Any]														=						in_proj_weight_cross_attn[:2_56, :]
          __lowerCamelCase  :      List[str]														=						in_proj_bias_cross_attn[:2_56]
          __lowerCamelCase  :      int														=						in_proj_weight_cross_attn[2_56:5_12, :]
          __lowerCamelCase  :      List[Any]														=						in_proj_bias_cross_attn[2_56:5_12]
          __lowerCamelCase  :      int														=						in_proj_weight_cross_attn[-2_56:, :]
          __lowerCamelCase  :      Optional[int]														=						in_proj_bias_cross_attn[-2_56:]



def      UpperCAmelCase__   (      UpperCAmelCase_       :							List[Any] ,       UpperCAmelCase_       :							Dict				)	->						Any:
     __lowerCamelCase							,			__lowerCamelCase  :      List[str]														=						image.size
     __lowerCamelCase  :      Union[str, Any]														=						max(__a ,       __a				)
     __lowerCamelCase  :      Dict														=						8_00 if 'detection' in checkpoint_url else 10_00
     __lowerCamelCase  :      List[str]														=						target_max_size / current_max_size
     __lowerCamelCase  :      Optional[Any]														=						image.resize((int(round(scale * width				)				), int(round(scale * height				)				))				)

     return resized_image



def      UpperCAmelCase__   (      UpperCAmelCase_       :							str				)	->						int:
     __lowerCamelCase  :      Optional[int]														=						F.to_tensor(__a				)
     __lowerCamelCase  :      Tuple														=						F.normalize(__a ,       mean=[0.485, 0.456, 0.406] ,       std=[0.229, 0.224, 0.225]				)
     return image



@torch.no_grad()
def      UpperCAmelCase__   (      UpperCAmelCase_       :							int ,       UpperCAmelCase_       :							str ,       UpperCAmelCase_       :							Dict				)	->						List[str]:
     logger.info('Converting model...'				)

     # load original state dict
     __lowerCamelCase  :      Optional[Any]														=						torch.hub.load_state_dict_from_url(__a ,       map_location='cpu'				)
     # rename keys
     for src, dest in rename_keys:
          rename_key(__a ,       __a ,       __a				)
     __lowerCamelCase  :      int														=						rename_backbone_keys(__a				)
     # query, key and value matrices need special treatment
     read_in_q_k_v(__a				)
     # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
     __lowerCamelCase  :      str														=						'model.'
     for key in state_dict.copy().keys():
          if not key.startswith('class_labels_classifier'				) and not key.startswith('bbox_predictor'				):
               __lowerCamelCase  :      List[Any]														=						state_dict.pop(__a				)
               __lowerCamelCase  :      str														=						val
    # create HuggingFace model and load state dict
     __lowerCamelCase  :      Dict														=						TableTransformerConfig(
         backbone='resnet18' ,       mask_loss_coefficient=1 ,       dice_loss_coefficient=1 ,       ce_loss_coefficient=1 ,       bbox_loss_coefficient=5 ,       giou_loss_coefficient=2 ,       eos_coefficient=0.4 ,       class_cost=1 ,       bbox_cost=5 ,       giou_cost=2 ,       )

     if "detection" in checkpoint_url:
          __lowerCamelCase  :      Optional[int]														=						15
          __lowerCamelCase  :      Any														=						2
          __lowerCamelCase  :      Optional[Any]														=						{0: 'table', 1: 'table rotated'}
          __lowerCamelCase  :      Tuple														=						idalabel
          __lowerCamelCase  :      List[str]														=						{v: k for k, v in idalabel.items()}
     else:
          __lowerCamelCase  :      int														=						1_25
          __lowerCamelCase  :      Optional[int]														=						6
          __lowerCamelCase  :      List[str]														=						{
              0: 'table',
              1: 'table column',
              2: 'table row',
              3: 'table column header',
              4: 'table projected row header',
              5: 'table spanning cell',
          }
          __lowerCamelCase  :      List[Any]														=						idalabel
          __lowerCamelCase  :      str														=						{v: k for k, v in idalabel.items()}

     __lowerCamelCase  :      Union[str, Any]														=						DetrImageProcessor(
         format='coco_detection' ,       max_size=8_00 if 'detection' in checkpoint_url else 10_00				)
     __lowerCamelCase  :      List[str]														=						TableTransformerForObjectDetection(__a				)
     model.load_state_dict(__a				)
     model.eval()

     # verify our conversion
     __lowerCamelCase  :      int														=						'example_pdf.png' if 'detection' in checkpoint_url else 'example_table.png'
     __lowerCamelCase  :      List[Any]														=						hf_hub_download(repo_id='nielsr/example-pdf' ,       repo_type='dataset' ,       filename=__a				)
     __lowerCamelCase  :      Optional[Any]														=						Image.open(__a				).convert('RGB'				)
     __lowerCamelCase  :      Dict														=						normalize(resize(__a ,       __a				)				).unsqueeze(0				)

     __lowerCamelCase  :      List[Any]														=						model(__a				)

     if "detection" in checkpoint_url:
          __lowerCamelCase  :      List[Any]														=						(1, 15, 3)
          __lowerCamelCase  :      List[str]														=						torch.tensor(
              [[-6.7_897, -16.9_985, 6.7_937], [-8.0_186, -22.2_192, 6.9_677], [-7.3_117, -21.0_708, 7.4_055]]				)
          __lowerCamelCase  :      Union[str, Any]														=						torch.tensor([[0.4_867, 0.1_767, 0.6_732], [0.6_718, 0.4_479, 0.3_830], [0.4_716, 0.1_760, 0.6_364]]				)

     else:
          __lowerCamelCase  :      Any														=						(1, 1_25, 7)
          __lowerCamelCase  :      List[str]														=						torch.tensor(
              [[-18.1_430, -8.3_214, 4.8_274], [-18.4_685, -7.1_361, -4.2_667], [-26.3_693, -9.3_429, -4.9_962]]				)
          __lowerCamelCase  :      Union[str, Any]														=						torch.tensor([[0.4_983, 0.5_595, 0.9_440], [0.4_916, 0.6_315, 0.5_954], [0.6_108, 0.8_637, 0.1_135]]				)

     assert outputs.logits.shape == expected_shape
     assert torch.allclose(outputs.logits[0, :3, :3] ,       __a ,       atol=1e-4				)
     assert torch.allclose(outputs.pred_boxes[0, :3, :3] ,       __a ,       atol=1e-4				)
     print('Looks ok!'				)

     if pytorch_dump_folder_path is not None:
          # Save model and image processor
          logger.info(F'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'				)
          Path(__a				).mkdir(exist_ok=__a				)
          model.save_pretrained(__a				)
          image_processor.save_pretrained(__a				)

     if push_to_hub:
          # Push model to HF hub
          logger.info('Pushing model to the hub...'				)
          __lowerCamelCase  :      Optional[Any]														=						(
              'microsoft/table-transformer-detection'
              if 'detection' in checkpoint_url
              else 'microsoft/table-transformer-structure-recognition'
          )
          model.push_to_hub(__a				)
          image_processor.push_to_hub(__a				)


if __name__ == "__main__":
      A__						:   List[str]				=    argparse.ArgumentParser()

      parser.add_argument(
          """--checkpoint_url""",
          default="""https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth""",
          type=str,
          choices=[
              """https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth""",
              """https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth""",
          ],
          help="""URL of the Table Transformer checkpoint you\'d like to convert.""",
      )
      parser.add_argument(
          """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
      )
      parser.add_argument(
          """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
      )
      A__						:   Dict				=    parser.parse_args()
      convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)








"""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)




