


import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor






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

							return name






def   _lowercase(					__a				:						Any    ,     __a				:						Any     ):
							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[1]     )
																					if "decoder_blocks" in key:
																												a__      =config.decoder_hidden_size
																												a__      ='decoder.decoder_layers.'
																												if "weight" in key:
																																			a__      =val[:dim, :]
																																			a__      =val[dim : dim * 2, :]
																																			a__      =val[-dim:, :]
																												elif "bias" in key:
																																			a__      =val[:dim]
																																			a__      =val[dim : dim * 2]
																																			a__      =val[-dim:]
																					else:
																												a__      =config.hidden_size
																												a__      ='vit.encoder.layer.'
																												if "weight" in key:
																																			a__      =val[:dim, :]
																																			a__      =val[dim : dim * 2, :]
																																			a__      =val[-dim:, :]
																												elif "bias" in key:
																																			a__      =val[:dim]
																																			a__      =val[dim : dim * 2]
																																			a__      =val[-dim:]

														else:
																					a__      =val

							return orig_state_dict






def   _lowercase(					__a				:						Any    ,     __a				:						Optional[Any]     ):
							a__      =ViTMAEConfig()
							if "large" in checkpoint_url:
														a__      =1024
														a__      =4096
														a__      =24
														a__      =16
							elif "huge" in checkpoint_url:
														a__      =14
														a__      =1280
														a__      =5120
														a__      =32
														a__      =16

							a__      =ViTMAEForPreTraining(__a     )

							a__      =torch.hub.load_state_dict_from_url(__a    ,     map_location='cpu'     )['model']

							a__      =ViTMAEImageProcessor(size=config.image_size     )

							a__      =convert_state_dict(__a    ,     __a     )

							model.load_state_dict(__a     )
							model.eval()

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

							a__      =Image.open(requests.get(__a    ,     stream=__a     ).raw     )
							a__      =ViTMAEImageProcessor(size=config.image_size     )
							a__      =image_processor(images=__a    ,     return_tensors='pt'     )

							# forward pass
							torch.manual_seed(2     )
							a__      =model(**__a     )
							a__      =outputs.logits

							if "large" in checkpoint_url:
														a__      =torch.tensor(
														    [[-0.73_09, -0.71_28, -1.01_69], [-1.01_61, -0.90_58, -1.18_78], [-1.04_78, -0.94_11, -1.19_11]]     )
							elif "huge" in checkpoint_url:
														a__      =torch.tensor(
														    [[-1.15_99, -0.91_99, -1.22_21], [-1.19_52, -0.92_69, -1.23_07], [-1.21_43, -0.93_37, -1.22_62]]     )
							else:
														a__      =torch.tensor(
														    [[-0.91_92, -0.84_81, -1.12_59], [-1.13_49, -1.00_34, -1.25_99], [-1.17_57, -1.04_29, -1.27_26]]     )

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

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

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


if __name__ == "__main__":
	_lowerCAmelCase:						Dict   				=       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:						str   				=       parser.parse_args()
	convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)





from typing import List, Optional

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


_lowerCAmelCase:						List[Any]   				=       logging.get_logger(__name__)

_lowerCAmelCase:						Any   				=       {
    'huggingface/autoformer-tourism-monthly': 'https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json',
}




class       lowercase_					(lowercase__   ):
				snake_case	    ='autoformer'
				snake_case	    ={
				    'hidden_size': 'd_model',
				    'num_attention_heads': 'encoder_attention_heads',
				    'num_hidden_layers': 'encoder_layers',
				}





				def __init__(				self       ,  lowercase_ = None       ,  lowercase_ = None       ,  lowercase_ = "student_t"       ,  lowercase_ = "nll"       ,  lowercase_ = 1       ,  lowercase_ = [1, 2, 3, 4, 5, 6, 7]       ,  lowercase_ = True       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = None       ,  lowercase_ = None       ,  lowercase_ = 64       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 32       ,  lowercase_ = 32       ,  lowercase_ = "gelu"       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 100       ,  lowercase_ = 0.02       ,  lowercase_ = True       ,  lowercase_=True       ,  lowercase_ = 10       ,  lowercase_ = 25       ,  lowercase_ = 3       ,  **lowercase_       ,  )  -> Union[str, Any]:
											# time series specific configuration
											a__      =prediction_length
											a__      =context_length if context_length is not None else prediction_length
											a__      =distribution_output
											a__      =loss
											a__      =input_size
											a__      =num_time_features
											a__      =lags_sequence
											a__      =scaling
											a__      =num_dynamic_real_features
											a__      =num_static_real_features
											a__      =num_static_categorical_features
											if cardinality is not None and num_static_categorical_features > 0:
																		if len(lowercase_) != num_static_categorical_features:
																									raise ValueError(
																									    'The cardinality should be a list of the same length as `num_static_categorical_features`')
																		a__      =cardinality
											else:
																		a__      =[0]
											if embedding_dimension is not None and num_static_categorical_features > 0:
																		if len(lowercase_) != num_static_categorical_features:
																									raise ValueError(
																									    'The embedding dimension should be a list of the same length as `num_static_categorical_features`')
																		a__      =embedding_dimension
											else:
																		a__      =[min(50       ,  (cat + 1) // 2) for cat in self.cardinality]
											a__      =num_parallel_samples

											# Transformer architecture configuration
											a__      =input_size * len(self.lags_sequence) + self._number_of_features
											a__      =d_model
											a__      =encoder_attention_heads
											a__      =decoder_attention_heads
											a__      =encoder_ffn_dim
											a__      =decoder_ffn_dim
											a__      =encoder_layers
											a__      =decoder_layers

											a__      =dropout
											a__      =attention_dropout
											a__      =activation_dropout
											a__      =encoder_layerdrop
											a__      =decoder_layerdrop

											a__      =activation_function
											a__      =init_std

											a__      =use_cache

											# Autoformer
											a__      =label_length
											a__      =moving_average
											a__      =autocorrelation_factor

											super().__init__(is_encoder_decoder=lowercase_       ,  **lowercase_)





				@property
				def 						__UpperCamelCase    (				self)  -> int:
											return (
											    sum(self.embedding_dimension)
											    + self.num_dynamic_real_features
											    + self.num_time_features
											    + self.num_static_real_features
											    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
											)

