



'''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()
snake_case_ :	int         =  logging.get_logger(__name__)






def A__    (     UpperCAmelCase_							):
						_UpperCamelCase					:		List[str] 				=   ASTConfig()

						if "10-10" in model_name:
												pass
						elif "speech-commands" in model_name:
												_UpperCamelCase					:		Tuple 				=   1_2_8
						elif "12-12" in model_name:
												_UpperCamelCase					:		Tuple 				=   1_2
												_UpperCamelCase					:		Tuple 				=   1_2
						elif "14-14" in model_name:
												_UpperCamelCase					:		Optional[Any] 				=   1_4
												_UpperCamelCase					:		Union[str, Any] 				=   1_4
						elif "16-16" in model_name:
												_UpperCamelCase					:		Dict 				=   1_6
												_UpperCamelCase					:		Optional[Any] 				=   1_6
						else:
												raise ValueError('Model not supported'							)

						_UpperCamelCase					:		Optional[int] 				=   'huggingface/label-files'
						if "speech-commands" in model_name:
												_UpperCamelCase					:		List[str] 				=   3_5
												_UpperCamelCase					:		List[str] 				=   'speech-commands-v2-id2label.json'
						else:
												_UpperCamelCase					:		Union[str, Any] 				=   5_2_7
												_UpperCamelCase					:		str 				=   'audioset-id2label.json'

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

						return config






def A__    (     UpperCAmelCase_							):
						if "module.v" in name:
												_UpperCamelCase					:		str 				=   name.replace('module.v'  ,  'audio_spectrogram_transformer'							)
						if "cls_token" in name:
												_UpperCamelCase					:		Dict 				=   name.replace('cls_token'  ,  'embeddings.cls_token'							)
						if "dist_token" in name:
												_UpperCamelCase					:		str 				=   name.replace('dist_token'  ,  'embeddings.distillation_token'							)
						if "pos_embed" in name:
												_UpperCamelCase					:		Dict 				=   name.replace('pos_embed'  ,  'embeddings.position_embeddings'							)
						if "patch_embed.proj" in name:
												_UpperCamelCase					:		List[Any] 				=   name.replace('patch_embed.proj'  ,  'embeddings.patch_embeddings.projection'							)
						# transformer blocks
						if "blocks" in name:
												_UpperCamelCase					:		List[str] 				=   name.replace('blocks'  ,  'encoder.layer'							)
						if "attn.proj" in name:
												_UpperCamelCase					:		Optional[Any] 				=   name.replace('attn.proj'  ,  'attention.output.dense'							)
						if "attn" in name:
												_UpperCamelCase					:		Dict 				=   name.replace('attn'  ,  'attention.self'							)
						if "norm1" in name:
												_UpperCamelCase					:		Optional[Any] 				=   name.replace('norm1'  ,  'layernorm_before'							)
						if "norm2" in name:
												_UpperCamelCase					:		str 				=   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					:		List[Any] 				=   name.replace('mlp.fc2'  ,  'output.dense'							)
						# final layernorm
						if "audio_spectrogram_transformer.norm" in name:
												_UpperCamelCase					:		Any 				=   name.replace('audio_spectrogram_transformer.norm'  ,  'audio_spectrogram_transformer.layernorm'							)
						# classifier head
						if "module.mlp_head.0" in name:
												_UpperCamelCase					:		List[str] 				=   name.replace('module.mlp_head.0'  ,  'classifier.layernorm'							)
						if "module.mlp_head.1" in name:
												_UpperCamelCase					:		int 				=   name.replace('module.mlp_head.1'  ,  'classifier.dense'							)

						return name






def A__    (     UpperCAmelCase_  ,  UpperCAmelCase_							):
						for key in orig_state_dict.copy().keys():
												_UpperCamelCase					:		Tuple 				=   orig_state_dict.pop(UpperCAmelCase_							)

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

						return orig_state_dict






def A__    (     UpperCAmelCase_							):
						_UpperCamelCase					:		List[str] 				=   [
						    '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(UpperCAmelCase_  ,  UpperCAmelCase_							)






@torch.no_grad()
def A__    (     UpperCAmelCase_  ,  UpperCAmelCase_  ,  UpperCAmelCase_=False							):
						_UpperCamelCase					:		str 				=   get_audio_spectrogram_transformer_config(UpperCAmelCase_							)

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

						# load 🤗 model
						_UpperCamelCase					:		Dict 				=   ASTForAudioClassification(UpperCAmelCase_							)
						model.eval()

						model.load_state_dict(UpperCAmelCase_							)

						# verify outputs on dummy input
						# source: https://github.com/YuanGongND/ast/blob/79e873b8a54d0a3b330dd522584ff2b9926cd581/src/run.py#L62
						_UpperCamelCase					:		List[Any] 				=   -4.2_677_393 if 'speech-commands' not in model_name else -6.845_978
						_UpperCamelCase					:		str 				=   4.5_689_974 if 'speech-commands' not in model_name else 5.5_654_526
						_UpperCamelCase					:		Tuple 				=   1_0_2_4 if 'speech-commands' not in model_name else 1_2_8
						_UpperCamelCase					:		Union[str, Any] 				=   ASTFeatureExtractor(mean=UpperCAmelCase_  ,  std=UpperCAmelCase_  ,  max_length=UpperCAmelCase_							)

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

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

						_UpperCamelCase					:		Tuple 				=   feature_extractor(UpperCAmelCase_  ,  sampling_rate=1_6_0_0_0  ,  return_tensors='pt'							)

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

						if model_name == "ast-finetuned-audioset-10-10-0.4593":
												_UpperCamelCase					:		List[str] 				=   torch.tensor([-0.8_760, -7.0_042, -8.6_602]							)
						elif model_name == "ast-finetuned-audioset-10-10-0.450":
												_UpperCamelCase					:		int 				=   torch.tensor([-1.1_986, -7.0_903, -8.2_718]							)
						elif model_name == "ast-finetuned-audioset-10-10-0.448":
												_UpperCamelCase					:		List[str] 				=   torch.tensor([-2.6_128, -8.0_080, -9.4_344]							)
						elif model_name == "ast-finetuned-audioset-10-10-0.448-v2":
												_UpperCamelCase					:		Optional[Any] 				=   torch.tensor([-1.5_080, -7.4_534, -8.8_917]							)
						elif model_name == "ast-finetuned-audioset-12-12-0.447":
												_UpperCamelCase					:		List[Any] 				=   torch.tensor([-0.5_050, -6.5_833, -8.0_843]							)
						elif model_name == "ast-finetuned-audioset-14-14-0.443":
												_UpperCamelCase					:		List[str] 				=   torch.tensor([-0.3_826, -7.0_336, -8.2_413]							)
						elif model_name == "ast-finetuned-audioset-16-16-0.442":
												_UpperCamelCase					:		Optional[Any] 				=   torch.tensor([-1.2_113, -6.9_101, -8.3_470]							)
						elif model_name == "ast-finetuned-speech-commands-v2":
												_UpperCamelCase					:		Optional[Any] 				=   torch.tensor([6.1_589, -8.0_566, -8.7_984]							)
						else:
												raise ValueError('Unknown model name'							)
						if not torch.allclose(logits[0, :3]  ,  UpperCAmelCase_  ,  atol=1E-4							):
												raise ValueError('Logits don\'t match'							)
						print('Looks ok!'							)

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

						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__":
					snake_case_ :	Union[str, Any]         =  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.'
					)

					snake_case_ :	Optional[int]         =  parser.parse_args()
					convert_audio_spectrogram_transformer_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








from __future__ import annotations




def 					lowerCamelCase__       (						A__       :					list[int]  ,			A__       :					list[int]  ,			A__       :					list[int]  ,			A__       :					list[list[str]]  ,			A__       :					int  ,			):





       '''simple docstring'''



       __lowerCamelCase   =						len(A__	)

       # If row is equal to the size of the board it means there are a queen in each row in
       # the current board (possible_board)
       if row == n:
              # We convert the variable possible_board that looks like this: [1, 3, 0, 2] to
              # this: ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . ']
              boards.append([""". """ * i + """Q """ + """. """ * (n - 1 - i) for i in possible_board]	)
              return

       # We iterate each column in the row to find all possible results in each row
       for col in range(A__	):
              # We apply that we learned previously. First we check that in the current board
              # (possible_board) there are not other same value because if there is it means
              # that there are a collision in vertical. Then we apply the two formulas we
              # learned before:
              #
              # 45º: y - x = b or 45: row - col = b
              # 135º: y + x = b or row + col = b.
              #
              # And we verify if the results of this two formulas not exist in their variables
              # respectively.  (diagonal_right_collisions, diagonal_left_collisions)
              #
              # If any or these are True it means there is a collision so we continue to the
              # next value in the for loop.
              if (
                  col in possible_board
                  or row - col in diagonal_right_collisions
                  or row + col in diagonal_left_collisions
              ):
                     continue

              # If it is False we call dfs function again and we update the inputs
              depth_first_search(
                  [*possible_board, col]  ,			[*diagonal_right_collisions, row - col]  ,			[*diagonal_left_collisions, row + col]  ,			A__  ,			A__  ,			)




def 					lowerCamelCase__       (						A__       :					int	):





       '''simple docstring'''



       __lowerCamelCase   =						[]
       depth_first_search([]  ,			[]  ,			[]  ,			A__  ,			A__	)

       # Print all the boards
       for board in boards:
              for column in board:
                     print(A__	)
              print(""""""	)

       print(len(A__	)  ,			"""solutions were found."""	)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       n_queens_solution(4)

