



import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor





def 		__lowerCamelCase							(UpperCAmelCase__       :							Optional[Any]					):
					if "cls_token" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("cls_token" ,	"vit.embeddings.cls_token"					)
					if "mask_token" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("mask_token" ,	"decoder.mask_token"					)
					if "decoder_pos_embed" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("decoder_pos_embed" ,	"decoder.decoder_pos_embed"					)
					if "pos_embed" in name and "decoder" not in name:
										SCREAMING_SNAKE_CASE           =    name.replace("pos_embed" ,	"vit.embeddings.position_embeddings"					)
					if "patch_embed.proj" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("patch_embed.proj" ,	"vit.embeddings.patch_embeddings.projection"					)
					if "patch_embed.norm" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("patch_embed.norm" ,	"vit.embeddings.norm"					)
					if "decoder_blocks" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("decoder_blocks" ,	"decoder.decoder_layers"					)
					if "blocks" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("blocks" ,	"vit.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"					)
					if "decoder_embed" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("decoder_embed" ,	"decoder.decoder_embed"					)
					if "decoder_norm" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("decoder_norm" ,	"decoder.decoder_norm"					)
					if "decoder_pred" in name:
										SCREAMING_SNAKE_CASE           =    name.replace("decoder_pred" ,	"decoder.decoder_pred"					)
					if "norm.weight" in name and "decoder" not in name:
										SCREAMING_SNAKE_CASE           =    name.replace("norm.weight" ,	"vit.layernorm.weight"					)
					if "norm.bias" in name and "decoder" not in name:
										SCREAMING_SNAKE_CASE           =    name.replace("norm.bias" ,	"vit.layernorm.bias"					)

					return name





def 		__lowerCamelCase							(UpperCAmelCase__       :							Dict ,	UpperCAmelCase__       :							Any					):
					for key in orig_state_dict.copy().keys():
										SCREAMING_SNAKE_CASE           =    orig_state_dict.pop(UpperCAmelCase__					)

										if "qkv" in key:
															SCREAMING_SNAKE_CASE           =    key.split("."					)
															SCREAMING_SNAKE_CASE           =    int(key_split[1]					)
															if "decoder_blocks" in key:
																				SCREAMING_SNAKE_CASE           =    config.decoder_hidden_size
																				SCREAMING_SNAKE_CASE           =    "decoder.decoder_layers."
																				if "weight" in key:
																									SCREAMING_SNAKE_CASE           =    val[:dim, :]
																									SCREAMING_SNAKE_CASE           =    val[dim : dim * 2, :]
																									SCREAMING_SNAKE_CASE           =    val[-dim:, :]
																				elif "bias" in key:
																									SCREAMING_SNAKE_CASE           =    val[:dim]
																									SCREAMING_SNAKE_CASE           =    val[dim : dim * 2]
																									SCREAMING_SNAKE_CASE           =    val[-dim:]
															else:
																				SCREAMING_SNAKE_CASE           =    config.hidden_size
																				SCREAMING_SNAKE_CASE           =    "vit.encoder.layer."
																				if "weight" in key:
																									SCREAMING_SNAKE_CASE           =    val[:dim, :]
																									SCREAMING_SNAKE_CASE           =    val[dim : dim * 2, :]
																									SCREAMING_SNAKE_CASE           =    val[-dim:, :]
																				elif "bias" in key:
																									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__       :							int ,	UpperCAmelCase__       :							Union[str, Any]					):
					SCREAMING_SNAKE_CASE           =    ViTMAEConfig()
					if "large" in checkpoint_url:
										SCREAMING_SNAKE_CASE           =    1_0_2_4
										SCREAMING_SNAKE_CASE           =    4_0_9_6
										SCREAMING_SNAKE_CASE           =    2_4
										SCREAMING_SNAKE_CASE           =    1_6
					elif "huge" in checkpoint_url:
										SCREAMING_SNAKE_CASE           =    1_4
										SCREAMING_SNAKE_CASE           =    1_2_8_0
										SCREAMING_SNAKE_CASE           =    5_1_2_0
										SCREAMING_SNAKE_CASE           =    3_2
										SCREAMING_SNAKE_CASE           =    1_6

					SCREAMING_SNAKE_CASE           =    ViTMAEForPreTraining(UpperCAmelCase__					)

					SCREAMING_SNAKE_CASE           =    torch.hub.load_state_dict_from_url(UpperCAmelCase__ ,	map_location="cpu"					)["model"]

					SCREAMING_SNAKE_CASE           =    ViTMAEImageProcessor(size=config.image_size					)

					SCREAMING_SNAKE_CASE           =    convert_state_dict(UpperCAmelCase__ ,	UpperCAmelCase__					)

					model.load_state_dict(UpperCAmelCase__					)
					model.eval()

					SCREAMING_SNAKE_CASE           =    "https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg"

					SCREAMING_SNAKE_CASE           =    Image.open(requests.get(UpperCAmelCase__ ,	stream=UpperCAmelCase__					).raw					)
					SCREAMING_SNAKE_CASE           =    ViTMAEImageProcessor(size=config.image_size					)
					SCREAMING_SNAKE_CASE           =    image_processor(images=UpperCAmelCase__ ,	return_tensors="pt"					)

					# forward pass
					torch.manual_seed(2					)
					SCREAMING_SNAKE_CASE           =    model(**UpperCAmelCase__					)
					SCREAMING_SNAKE_CASE           =    outputs.logits

					if "large" in checkpoint_url:
										SCREAMING_SNAKE_CASE           =    torch.tensor(
										    [[-0.7309, -0.7128, -1.0169], [-1.0161, -0.9058, -1.1878], [-1.0478, -0.9411, -1.1911]]					)
					elif "huge" in checkpoint_url:
										SCREAMING_SNAKE_CASE           =    torch.tensor(
										    [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]					)
					else:
										SCREAMING_SNAKE_CASE           =    torch.tensor(
										    [[-0.9192, -0.8481, -1.1259], [-1.1349, -1.0034, -1.2599], [-1.1757, -1.0429, -1.2726]]					)

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

					print(F"Saving model to {pytorch_dump_folder_path}"					)
					model.save_pretrained(UpperCAmelCase__					)

					print(F"Saving image processor to {pytorch_dump_folder_path}"					)
					image_processor.save_pretrained(UpperCAmelCase__					)


if __name__ == "__main__":
							_lowerCamelCase   :				Tuple     			=						argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '''--checkpoint_url''',
							    default='''https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_base.pth''',
							    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.'''
							)

							_lowerCamelCase   :				Tuple     			=						parser.parse_args()
							convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_lowerCamelCase   :				int     			=						logging.get_logger(__name__)

_lowerCamelCase   :				Union[str, Any]     			=						{
    '''microsoft/unispeech-sat-base-100h-libri-ft''': (
        '''https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json'''
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}


class   lowercase      (       a       ):
							lowercase__  :    Tuple									=							"""unispeech-sat"""




							def __init__(  self				:   str		,							_UpperCamelCase				:   Tuple=32		,							_UpperCamelCase				:   Union[str, Any]=768		,							_UpperCamelCase				:   Tuple=12		,							_UpperCamelCase				:   List[str]=12		,							_UpperCamelCase				:   Tuple=3_072		,							_UpperCamelCase				:   List[str]="gelu"		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   Any=0.1		,							_UpperCamelCase				:   Union[str, Any]=0.1		,							_UpperCamelCase				:   Dict=0.0		,							_UpperCamelCase				:   Tuple=0.0		,							_UpperCamelCase				:   Tuple=0.1		,							_UpperCamelCase				:   Optional[Any]=0.1		,							_UpperCamelCase				:   Tuple=0.0_2		,							_UpperCamelCase				:   Optional[int]=1e-5		,							_UpperCamelCase				:   Union[str, Any]="group"		,							_UpperCamelCase				:   Optional[int]="gelu"		,							_UpperCamelCase				:   Tuple=(512, 512, 512, 512, 512, 512, 512)		,							_UpperCamelCase				:   List[str]=(5, 2, 2, 2, 2, 2, 2)		,							_UpperCamelCase				:   Optional[int]=(10, 3, 3, 3, 3, 2, 2)		,							_UpperCamelCase				:   Optional[int]=False		,							_UpperCamelCase				:   Dict=128		,							_UpperCamelCase				:   Optional[int]=16		,							_UpperCamelCase				:   Tuple=False		,							_UpperCamelCase				:   Union[str, Any]=True		,							_UpperCamelCase				:   Optional[Any]=0.0_5		,							_UpperCamelCase				:   Union[str, Any]=10		,							_UpperCamelCase				:   Union[str, Any]=2		,							_UpperCamelCase				:   str=0.0		,							_UpperCamelCase				:   List[Any]=10		,							_UpperCamelCase				:   Optional[int]=0		,							_UpperCamelCase				:   Any=320		,							_UpperCamelCase				:   List[Any]=2		,							_UpperCamelCase				:   str=0.1		,							_UpperCamelCase				:   str=100		,							_UpperCamelCase				:   int=256		,							_UpperCamelCase				:   Optional[Any]=256		,							_UpperCamelCase				:   List[Any]=0.1		,							_UpperCamelCase				:   str="mean"		,							_UpperCamelCase				:   int=False		,							_UpperCamelCase				:   Optional[Any]=False		,							_UpperCamelCase				:   Any=256		,							_UpperCamelCase				:   str=(512, 512, 512, 512, 1_500)		,							_UpperCamelCase				:   List[Any]=(5, 3, 3, 1, 1)		,							_UpperCamelCase				:   Union[str, Any]=(1, 2, 3, 1, 1)		,							_UpperCamelCase				:   Any=512		,							_UpperCamelCase				:   str=0		,							_UpperCamelCase				:   int=1		,							_UpperCamelCase				:   Any=2		,							_UpperCamelCase				:   Optional[Any]=504		,							**_UpperCamelCase				:   str		,							)   ->			int:



												'''simple docstring'''

												super().__init__(**_UpperCamelCase		,							pad_token_id=_UpperCamelCase		,							bos_token_id=_UpperCamelCase		,							eos_token_id=_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    hidden_size
												SCREAMING_SNAKE_CASE           =    feat_extract_norm
												SCREAMING_SNAKE_CASE           =    feat_extract_activation
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    conv_bias
												SCREAMING_SNAKE_CASE           =    num_conv_pos_embeddings
												SCREAMING_SNAKE_CASE           =    num_conv_pos_embedding_groups
												SCREAMING_SNAKE_CASE           =    len(self.conv_dim )
												SCREAMING_SNAKE_CASE           =    num_hidden_layers
												SCREAMING_SNAKE_CASE           =    intermediate_size
												SCREAMING_SNAKE_CASE           =    hidden_act
												SCREAMING_SNAKE_CASE           =    num_attention_heads
												SCREAMING_SNAKE_CASE           =    hidden_dropout
												SCREAMING_SNAKE_CASE           =    attention_dropout
												SCREAMING_SNAKE_CASE           =    activation_dropout
												SCREAMING_SNAKE_CASE           =    feat_proj_dropout
												SCREAMING_SNAKE_CASE           =    final_dropout
												SCREAMING_SNAKE_CASE           =    layerdrop
												SCREAMING_SNAKE_CASE           =    layer_norm_eps
												SCREAMING_SNAKE_CASE           =    initializer_range
												SCREAMING_SNAKE_CASE           =    vocab_size
												SCREAMING_SNAKE_CASE           =    num_clusters
												SCREAMING_SNAKE_CASE           =    do_stable_layer_norm
												SCREAMING_SNAKE_CASE           =    use_weighted_layer_sum

												if (
												    (len(self.conv_stride ) != self.num_feat_extract_layers)
												    or (len(self.conv_kernel ) != self.num_feat_extract_layers)
												    or (len(self.conv_dim ) != self.num_feat_extract_layers)
												):
																	raise ValueError(
																	    "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
																	    " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
																	    F" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,"
																	    F" `len(config.conv_kernel) = {len(self.conv_kernel )}`." )

												# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
												SCREAMING_SNAKE_CASE           =    apply_spec_augment
												SCREAMING_SNAKE_CASE           =    mask_time_prob
												SCREAMING_SNAKE_CASE           =    mask_time_length
												SCREAMING_SNAKE_CASE           =    mask_time_min_masks
												SCREAMING_SNAKE_CASE           =    mask_feature_prob
												SCREAMING_SNAKE_CASE           =    mask_feature_length
												SCREAMING_SNAKE_CASE           =    mask_feature_min_masks

												# parameters for pretraining with codevector quantized representations
												SCREAMING_SNAKE_CASE           =    num_codevectors_per_group
												SCREAMING_SNAKE_CASE           =    num_codevector_groups
												SCREAMING_SNAKE_CASE           =    contrastive_logits_temperature
												SCREAMING_SNAKE_CASE           =    feat_quantizer_dropout
												SCREAMING_SNAKE_CASE           =    num_negatives
												SCREAMING_SNAKE_CASE           =    codevector_dim
												SCREAMING_SNAKE_CASE           =    proj_codevector_dim
												SCREAMING_SNAKE_CASE           =    diversity_loss_weight

												# ctc loss
												SCREAMING_SNAKE_CASE           =    ctc_loss_reduction
												SCREAMING_SNAKE_CASE           =    ctc_zero_infinity

												# SequenceClassification-specific parameter. Feel free to ignore for other classes.
												SCREAMING_SNAKE_CASE           =    classifier_proj_size

												# XVector-specific parameters. Feel free to ignore for other classes.
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    list(_UpperCamelCase )
												SCREAMING_SNAKE_CASE           =    xvector_output_dim





							@property
							def 		__snake_case(  self				:   Tuple )   ->			str:



												'''simple docstring'''

												return functools.reduce(operator.mul		,							self.conv_stride		,							1 )




