

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


def        _lowerCAmelCase					(						_UpperCamelCase						:     Any				)      ->			int:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =ASTConfig()

     if "10-10" in model_name:
          pass
     elif "speech-commands" in model_name:
          _SCREAMING_SNAKE_CASE							    =1_28
     elif "12-12" in model_name:
          _SCREAMING_SNAKE_CASE							    =12
          _SCREAMING_SNAKE_CASE							    =12
     elif "14-14" in model_name:
          _SCREAMING_SNAKE_CASE							    =14
          _SCREAMING_SNAKE_CASE							    =14
     elif "16-16" in model_name:
          _SCREAMING_SNAKE_CASE							    =16
          _SCREAMING_SNAKE_CASE							    =16
     else:
          raise ValueError('Model not supported'				)

     _SCREAMING_SNAKE_CASE							    ='huggingface/label-files'
     if "speech-commands" in model_name:
          _SCREAMING_SNAKE_CASE							    =35
          _SCREAMING_SNAKE_CASE							    ='speech-commands-v2-id2label.json'
     else:
          _SCREAMING_SNAKE_CASE							    =5_27
          _SCREAMING_SNAKE_CASE							    ='audioset-id2label.json'

     _SCREAMING_SNAKE_CASE							    =json.load(open(hf_hub_download(snake_case_							, snake_case_							, repo_type='dataset'				)							, 'r'				)				)
     _SCREAMING_SNAKE_CASE							    ={int(snake_case_				): v for k, v in idalabel.items()}
     _SCREAMING_SNAKE_CASE							    =idalabel
     _SCREAMING_SNAKE_CASE							    ={v: k for k, v in idalabel.items()}

     return config


def        _lowerCAmelCase					(						_UpperCamelCase						:     List[str]				)      ->			Any:
     """simple docstring"""




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

     return name


def        _lowerCAmelCase					(						_UpperCamelCase						:     int							, _UpperCamelCase						:     Optional[Any]				)      ->			Union[str, Any]:
     """simple docstring"""




     for key in orig_state_dict.copy().keys():
          _SCREAMING_SNAKE_CASE							    =orig_state_dict.pop(snake_case_				)

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

     return orig_state_dict


def        _lowerCAmelCase					(						_UpperCamelCase						:     Any				)      ->			str:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =[
         '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(snake_case_							, snake_case_				)


@torch.no_grad()
def        _lowerCAmelCase					(						_UpperCamelCase						:     int							, _UpperCamelCase						:     Any							, _UpperCamelCase						:     Optional[int]=False				)      ->			List[Any]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =get_audio_spectrogram_transformer_config(snake_case_				)

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

     # load 🤗 model
     _SCREAMING_SNAKE_CASE							    =ASTForAudioClassification(snake_case_				)
     model.eval()

     model.load_state_dict(snake_case_				)

     # verify outputs on dummy input
     # source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
     _SCREAMING_SNAKE_CASE							    =-4.2_67_73_93 if 'speech-commands' not in model_name else -6.84_59_78
     _SCREAMING_SNAKE_CASE							    =4.5_68_99_74 if 'speech-commands' not in model_name else 5.5_65_45_26
     _SCREAMING_SNAKE_CASE							    =10_24 if 'speech-commands' not in model_name else 1_28
     _SCREAMING_SNAKE_CASE							    =ASTFeatureExtractor(mean=snake_case_							, std=snake_case_							, max_length=snake_case_				)

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

          _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =torchaudio.load(snake_case_				)
          _SCREAMING_SNAKE_CASE							    =waveform.squeeze().numpy()

     _SCREAMING_SNAKE_CASE							    =feature_extractor(snake_case_							, sampling_rate=1_60_00							, return_tensors='pt'				)

     # forward pass
     _SCREAMING_SNAKE_CASE							    =model(**snake_case_				)
     _SCREAMING_SNAKE_CASE							    =outputs.logits

     if model_name == "ast-finetuned-audioset-10-10-0.4593":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-0.87_60, -7.00_42, -8.66_02]				)
     elif model_name == "ast-finetuned-audioset-10-10-0.450":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-1.19_86, -7.09_03, -8.27_18]				)
     elif model_name == "ast-finetuned-audioset-10-10-0.448":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-2.61_28, -8.00_80, -9.43_44]				)
     elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-1.50_80, -7.45_34, -8.89_17]				)
     elif model_name == "ast-finetuned-audioset-12-12-0.447":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-0.50_50, -6.58_33, -8.08_43]				)
     elif model_name == "ast-finetuned-audioset-14-14-0.443":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-0.38_26, -7.03_36, -8.24_13]				)
     elif model_name == "ast-finetuned-audioset-16-16-0.442":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([-1.21_13, -6.91_01, -8.34_70]				)
     elif model_name == "ast-finetuned-speech-commands-v2":
          _SCREAMING_SNAKE_CASE							    =torch.tensor([6.15_89, -8.05_66, -8.79_84]				)
     else:
          raise ValueError('Unknown model name'				)
     if not torch.allclose(logits[0, :3]							, snake_case_							, atol=1E-4				):
          raise ValueError('Logits don\'t match'				)
     print('Looks ok!'				)

     if pytorch_dump_folder_path is not None:
          Path(snake_case_				).mkdir(exist_ok=snake_case_				)
          print(f"Saving model {model_name} to {pytorch_dump_folder_path}"				)
          model.save_pretrained(snake_case_				)
          print(f"Saving feature extractor to {pytorch_dump_folder_path}"				)
          feature_extractor.save_pretrained(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__":
     lowerCamelCase :      Tuple					 =     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."
     )

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

'''simple docstring'''





import json
import logging
import os
import sys
from pathlib import Path

import finetune_rag

from transformers.file_utils import is_apex_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    require_ray,
    require_torch_gpu,
    require_torch_multi_gpu,
)


logging.basicConfig(level=logging.DEBUG)
SCREAMING_SNAKE_CASE_:     Optional[int]  =logging.getLogger()

SCREAMING_SNAKE_CASE_:     Union[str, Any]  =logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)




class        __A      ( UpperCamelCase__	):



    def 					_lowercase						(self    :    Optional[Any]   ,			__a    :    str ):
         os.makedirs(__a   ,			exist_ok=__a )
         UpperCAmelCase_           =   {"source": "What is love ?", "target": "life"}
         UpperCAmelCase_           =   {"train": 12, "val": 2, "test": 2}
         for split in ["train", "test", "val"]:
              for field in ["source", "target"]:
                   UpperCAmelCase_           =   "\n".join([contents[field]] * n_lines[split] )
                   with open(os.path.join(__a   ,			f"""{split}.{field}""" )   ,			"w" ) as f:
                        f.write(__a )



    def 					_lowercase						(self    :    Optional[int]   ,			__a    :    int   ,			__a    :    str = "pytorch" ):
         UpperCAmelCase_           =   self.get_auto_remove_tmp_dir()
         UpperCAmelCase_           =   os.path.join(__a   ,			"output" )
         UpperCAmelCase_           =   os.path.join(__a   ,			"data" )
         self._create_dummy_data(data_dir=__a )

         UpperCAmelCase_           =   f"""
                --data_dir {data_dir} \
                --output_dir {output_dir} \
                --model_name_or_path facebook/rag-sequence-base \
                --model_type rag_sequence \
                --do_train \
                --do_predict \
                --n_val -1 \
                --val_check_interval 1.0 \
                --train_batch_size 2 \
                --eval_batch_size 1 \
                --max_source_length 25 \
                --max_target_length 25 \
                --val_max_target_length 25 \
                --test_max_target_length 25 \
                --label_smoothing 0.1 \
                --dropout 0.1 \
                --attention_dropout 0.1 \
                --weight_decay 0.001 \
                --adam_epsilon 1e-08 \
                --max_grad_norm 0.1 \
                --lr_scheduler polynomial \
                --learning_rate 3e-04 \
                --num_train_epochs 1 \
                --warmup_steps 4 \
                --gradient_accumulation_steps 1 \
                --distributed-port 8787 \
                --use_dummy_dataset 1 \
                --distributed_retriever {distributed_retriever} \
            """.split()

         if gpus > 0:
              testargs.append(f"""--gpus={gpus}""" )
              if is_apex_available():
                   testargs.append("--fp16" )
         else:
              testargs.append("--gpus=0" )
              testargs.append("--distributed_backend=ddp_cpu" )
              testargs.append("--num_processes=2" )

         UpperCAmelCase_           =   [sys.executable, str(Path(finetune_rag.__file__ ).resolve() )] + testargs
         execute_subprocess_async(__a   ,			env=self.get_env() )

         UpperCAmelCase_           =   os.path.join(__a   ,			"metrics.json" )
         with open(__a ) as f:
              UpperCAmelCase_           =   json.load(__a )
         return result



    @require_torch_gpu
    def 					_lowercase						(self    :    Optional[int] ):
         UpperCAmelCase_           =   self._run_finetune(gpus=1 )
         self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,			0.2 )



    @require_torch_multi_gpu
    def 					_lowercase						(self    :    Dict ):
         UpperCAmelCase_           =   self._run_finetune(gpus=2 )
         self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,			0.2 )



    @require_torch_gpu
    @require_ray
    def 					_lowercase						(self    :    Optional[int] ):
         UpperCAmelCase_           =   self._run_finetune(gpus=1   ,			distributed_retriever="ray" )
         self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,			0.2 )






    @require_torch_multi_gpu
    @require_ray
    def 					_lowercase						(self    :    Any ):
         UpperCAmelCase_           =   self._run_finetune(gpus=1   ,			distributed_retriever="ray" )
         self.assertGreaterEqual(result["test"][0]["test_avg_em"]   ,			0.2 )




