


"""simple docstring"""
import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE=False				)    ->				Tuple:
							snake_case_           =		[]
							for i in range(config.num_hidden_layers				):
														# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
														rename_keys.append((f"""module.blocks.{i}.norm1.weight""", f"""vit.encoder.layer.{i}.layernorm_before.weight""")				)
														rename_keys.append((f"""module.blocks.{i}.norm1.bias""", f"""vit.encoder.layer.{i}.layernorm_before.bias""")				)
														rename_keys.append(
														    (f"""module.blocks.{i}.attn.proj.weight""", f"""vit.encoder.layer.{i}.attention.output.dense.weight""")				)
														rename_keys.append((f"""module.blocks.{i}.attn.proj.bias""", f"""vit.encoder.layer.{i}.attention.output.dense.bias""")				)
														rename_keys.append((f"""module.blocks.{i}.norm2.weight""", f"""vit.encoder.layer.{i}.layernorm_after.weight""")				)
														rename_keys.append((f"""module.blocks.{i}.norm2.bias""", f"""vit.encoder.layer.{i}.layernorm_after.bias""")				)
														rename_keys.append((f"""module.blocks.{i}.mlp.fc1.weight""", f"""vit.encoder.layer.{i}.intermediate.dense.weight""")				)
														rename_keys.append((f"""module.blocks.{i}.mlp.fc1.bias""", f"""vit.encoder.layer.{i}.intermediate.dense.bias""")				)
														rename_keys.append((f"""module.blocks.{i}.mlp.fc2.weight""", f"""vit.encoder.layer.{i}.output.dense.weight""")				)
														rename_keys.append((f"""module.blocks.{i}.mlp.fc2.bias""", f"""vit.encoder.layer.{i}.output.dense.bias""")				)

							# projection layer + position embeddings
							rename_keys.extend(
							    [
							        ("""module.cls_token""", """vit.embeddings.cls_token"""),
							        ("""module.patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""),
							        ("""module.patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""),
							        ("""module.pos_embed""", """vit.embeddings.position_embeddings"""),
							    ]				)

							if base_model:
														# layernorm + pooler
														rename_keys.extend(
														    [
														        ("""module.norm.weight""", """layernorm.weight"""),
														        ("""module.norm.bias""", """layernorm.bias"""),
														    ]				)

														# if just the base model, we should remove "vit" from all keys that start with "vit"
														snake_case_           =		[(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""				) else pair for pair in rename_keys]
							else:
														# layernorm + classification head
														rename_keys.extend(
														    [
														        ("""norm.weight""", """vit.layernorm.weight"""),
														        ("""norm.bias""", """vit.layernorm.bias"""),
														        ("""head.weight""", """classifier.weight"""),
														        ("""head.bias""", """classifier.bias"""),
														    ]				)

							return rename_keys







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE=False				)    ->				int:
							for i in range(config.num_hidden_layers				):
														if base_model:
																					snake_case_           =		""""""
														else:
																					snake_case_           =		"""vit."""
														# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
														snake_case_           =		state_dict.pop(f"""module.blocks.{i}.attn.qkv.weight"""				)
														snake_case_           =		state_dict.pop(f"""module.blocks.{i}.attn.qkv.bias"""				)
														# next, add query, keys and values (in that order) to the state dict
														snake_case_           =		in_proj_weight[
														    : config.hidden_size, :
														]
														snake_case_           =		in_proj_bias[: config.hidden_size]
														snake_case_           =		in_proj_weight[
														    config.hidden_size : config.hidden_size * 2, :
														]
														snake_case_           =		in_proj_bias[
														    config.hidden_size : config.hidden_size * 2
														]
														snake_case_           =		in_proj_weight[
														    -config.hidden_size :, :
														]
														snake_case_           =		in_proj_bias[-config.hidden_size :]







def 						_a				(      _SCREAMING_SNAKE_CASE				)    ->				List[str]:
							snake_case_           =		["""head.weight""", """head.bias"""]
							for k in ignore_keys:
														state_dict.pop(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)







def 						_a				(      _SCREAMING_SNAKE_CASE				)    ->				List[Any]:
							# projection head is used in the self-supervised pre-training in MSN,
							# for downstream task it's not needed.
							snake_case_           =		[
							    """module.fc.fc1.weight""",
							    """module.fc.fc1.bias""",
							    """module.fc.bn1.weight""",
							    """module.fc.bn1.bias""",
							    """module.fc.bn1.running_mean""",
							    """module.fc.bn1.running_var""",
							    """module.fc.bn1.num_batches_tracked""",
							    """module.fc.fc2.weight""",
							    """module.fc.fc2.bias""",
							    """module.fc.bn2.weight""",
							    """module.fc.bn2.bias""",
							    """module.fc.bn2.running_mean""",
							    """module.fc.bn2.running_var""",
							    """module.fc.bn2.num_batches_tracked""",
							    """module.fc.fc3.weight""",
							    """module.fc.fc3.bias""",
							]
							for k in ignore_keys:
														state_dict.pop(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				Optional[int]:
							snake_case_           =		dct.pop(_SCREAMING_SNAKE_CASE				)
							snake_case_           =		val







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				List[str]:
							snake_case_           =		ViTMSNConfig()
							snake_case_           =		1_000

							snake_case_           =		"""datasets/huggingface/label-files"""
							snake_case_           =		"""imagenet-1k-id2label.json"""
							snake_case_           =		json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)				, """r"""				)				)
							snake_case_           =		{int(_SCREAMING_SNAKE_CASE				): v for k, v in idalabel.items()}
							snake_case_           =		idalabel
							snake_case_           =		{v: k for k, v in idalabel.items()}

							if "s16" in checkpoint_url:
														snake_case_           =		384
														snake_case_           =		1_536
														snake_case_           =		6
							elif "l16" in checkpoint_url:
														snake_case_           =		1_024
														snake_case_           =		4_096
														snake_case_           =		24
														snake_case_           =		16
														snake_case_           =		0.1
							elif "b4" in checkpoint_url:
														snake_case_           =		4
							elif "l7" in checkpoint_url:
														snake_case_           =		7
														snake_case_           =		1_024
														snake_case_           =		4_096
														snake_case_           =		24
														snake_case_           =		16
														snake_case_           =		0.1

							snake_case_           =		ViTMSNModel(_SCREAMING_SNAKE_CASE				)

							snake_case_           =		torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE				, map_location="""cpu"""				)["""target_encoder"""]

							snake_case_           =		ViTImageProcessor(size=config.image_size				)

							remove_projection_head(_SCREAMING_SNAKE_CASE				)
							snake_case_           =		create_rename_keys(_SCREAMING_SNAKE_CASE				, base_model=_SCREAMING_SNAKE_CASE				)

							for src, dest in rename_keys:
														rename_key(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)
							read_in_q_k_v(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, base_model=_SCREAMING_SNAKE_CASE				)

							model.load_state_dict(_SCREAMING_SNAKE_CASE				)
							model.eval()

							snake_case_           =		"""http://images.cocodataset.org/val2017/000000039769.jpg"""

							snake_case_           =		Image.open(requests.get(_SCREAMING_SNAKE_CASE				, stream=_SCREAMING_SNAKE_CASE				).raw				)
							snake_case_           =		ViTImageProcessor(
							    size=config.image_size				, image_mean=_SCREAMING_SNAKE_CASE				, image_std=_SCREAMING_SNAKE_CASE				)
							snake_case_           =		image_processor(images=_SCREAMING_SNAKE_CASE				, return_tensors="""pt"""				)

							# forward pass
							torch.manual_seed(2				)
							snake_case_           =		model(**_SCREAMING_SNAKE_CASE				)
							snake_case_           =		outputs.last_hidden_state

							# The following Colab Notebook was used to generate these outputs:
							# https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
							if "s16" in checkpoint_url:
														snake_case_           =		torch.tensor([[-1.0915, -1.4876, -1.1809]]				)
							elif "b16" in checkpoint_url:
														snake_case_           =		torch.tensor([[14.2889, -18.9045, 11.7281]]				)
							elif "l16" in checkpoint_url:
														snake_case_           =		torch.tensor([[41.5028, -22.8681, 45.6475]]				)
							elif "b4" in checkpoint_url:
														snake_case_           =		torch.tensor([[-4.3868, 5.2932, -0.4137]]				)
							else:
														snake_case_           =		torch.tensor([[-0.1792, -0.6465, 2.4263]]				)

							# verify logits
							assert torch.allclose(last_hidden_state[:, 0, :3]				, _SCREAMING_SNAKE_CASE				, atol=1E-4				)

							print(f"""Saving model to {pytorch_dump_folder_path}"""				)
							model.save_pretrained(_SCREAMING_SNAKE_CASE				)

							print(f"""Saving image processor to {pytorch_dump_folder_path}"""				)
							image_processor.save_pretrained(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE							:    Any		=    argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--checkpoint_url',
				    default='https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar',
				    type=str,
				    help='URL of the checkpoint you\'d like to convert.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
				)

				__SCREAMING_SNAKE_CASE							:    Any		=    parser.parse_args()
				convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)







"""simple docstring"""
import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate





@dataclass(frozen=snake_case__)
class      __A     (snake_case__):





							'''simple docstring'''

							__lowercase:		str							      =    field(default="""automatic-speech-recognition"""						,		metadata={"""include_in_asdict_even_if_is_default""": True})
							__lowercase:		ClassVar[Features]							      =    Features({"""audio""": Audio()})
							__lowercase:		ClassVar[Features]							      =    Features({"""transcription""": Value("""string""")})
							__lowercase:		str							      =    "audio"
							__lowercase:		str							      =    "transcription"



							def 		lowerCAmelCase       (				self							:      List[Any]		,       UpperCAmelCase_							:      Any       )					->int:



														"""simple docstring"""



														if self.audio_column not in features:
																					raise ValueError(F"""Column {self.audio_column} is not present in features."""       )
														if not isinstance(features[self.audio_column]		,       UpperCAmelCase_       ):
																					raise ValueError(F"""Column {self.audio_column} is not an Audio type."""       )
														snake_case_           =		copy.deepcopy(self       )
														snake_case_           =		self.input_schema.copy()
														snake_case_           =		features[self.audio_column]
														snake_case_           =		input_schema
														return task_template



							@property
							def 		lowerCAmelCase       (				self							:      List[str]       )					->Dict[str, str]:



														"""simple docstring"""



														return {self.audio_column: "audio", self.transcription_column: "transcription"}



