


'''simple docstring'''







import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor



def     _UpperCamelCase				(			UpperCamelCase__		):






				"""simple docstring"""



				if "cls_token" in name:
								__magic_name__					:       str    							=							name.replace("cls_token"  , "vit.embeddings.cls_token"		)
				if "mask_token" in name:
								__magic_name__					:       List[Any]    							=							name.replace("mask_token"  , "decoder.mask_token"		)
				if "decoder_pos_embed" in name:
								__magic_name__					:       str    							=							name.replace("decoder_pos_embed"  , "decoder.decoder_pos_embed"		)
				if "pos_embed" in name and "decoder" not in name:
								__magic_name__					:       str    							=							name.replace("pos_embed"  , "vit.embeddings.position_embeddings"		)
				if "patch_embed.proj" in name:
								__magic_name__					:       Tuple    							=							name.replace("patch_embed.proj"  , "vit.embeddings.patch_embeddings.projection"		)
				if "patch_embed.norm" in name:
								__magic_name__					:       Dict    							=							name.replace("patch_embed.norm"  , "vit.embeddings.norm"		)
				if "decoder_blocks" in name:
								__magic_name__					:       Optional[int]    							=							name.replace("decoder_blocks"  , "decoder.decoder_layers"		)
				if "blocks" in name:
								__magic_name__					:       Tuple    							=							name.replace("blocks"  , "vit.encoder.layer"		)
				if "attn.proj" in name:
								__magic_name__					:       Optional[Any]    							=							name.replace("attn.proj"  , "attention.output.dense"		)
				if "attn" in name:
								__magic_name__					:       Union[str, Any]    							=							name.replace("attn"  , "attention.self"		)
				if "norm1" in name:
								__magic_name__					:       Union[str, Any]    							=							name.replace("norm1"  , "layernorm_before"		)
				if "norm2" in name:
								__magic_name__					:       Optional[Any]    							=							name.replace("norm2"  , "layernorm_after"		)
				if "mlp.fc1" in name:
								__magic_name__					:       List[Any]    							=							name.replace("mlp.fc1"  , "intermediate.dense"		)
				if "mlp.fc2" in name:
								__magic_name__					:       Optional[int]    							=							name.replace("mlp.fc2"  , "output.dense"		)
				if "decoder_embed" in name:
								__magic_name__					:       Union[str, Any]    							=							name.replace("decoder_embed"  , "decoder.decoder_embed"		)
				if "decoder_norm" in name:
								__magic_name__					:       Union[str, Any]    							=							name.replace("decoder_norm"  , "decoder.decoder_norm"		)
				if "decoder_pred" in name:
								__magic_name__					:       Union[str, Any]    							=							name.replace("decoder_pred"  , "decoder.decoder_pred"		)
				if "norm.weight" in name and "decoder" not in name:
								__magic_name__					:       Any    							=							name.replace("norm.weight"  , "vit.layernorm.weight"		)
				if "norm.bias" in name and "decoder" not in name:
								__magic_name__					:       Dict    							=							name.replace("norm.bias"  , "vit.layernorm.bias"		)

				return name



def     _UpperCamelCase				(			UpperCamelCase__  , UpperCamelCase__		):






				"""simple docstring"""



				for key in orig_state_dict.copy().keys():
								__magic_name__					:       Union[str, Any]    							=							orig_state_dict.pop(UpperCamelCase__		)

								if "qkv" in key:
												__magic_name__					:       Dict    							=							key.split("."		)
												__magic_name__					:       Dict    							=							int(key_split[1]		)
												if "decoder_blocks" in key:
																__magic_name__					:       Any    							=							config.decoder_hidden_size
																__magic_name__					:       str    							=							"decoder.decoder_layers."
																if "weight" in key:
																				__magic_name__					:       str    							=							val[:dim, :]
																				__magic_name__					:       Optional[Any]    							=							val[dim : dim * 2, :]
																				__magic_name__					:       Dict    							=							val[-dim:, :]
																elif "bias" in key:
																				__magic_name__					:       Optional[int]    							=							val[:dim]
																				__magic_name__					:       Optional[Any]    							=							val[dim : dim * 2]
																				__magic_name__					:       Dict    							=							val[-dim:]
												else:
																__magic_name__					:       Dict    							=							config.hidden_size
																__magic_name__					:       Optional[int]    							=							"vit.encoder.layer."
																if "weight" in key:
																				__magic_name__					:       Tuple    							=							val[:dim, :]
																				__magic_name__					:       Optional[int]    							=							val[dim : dim * 2, :]
																				__magic_name__					:       int    							=							val[-dim:, :]
																elif "bias" in key:
																				__magic_name__					:       Optional[Any]    							=							val[:dim]
																				__magic_name__					:       List[Any]    							=							val[dim : dim * 2]
																				__magic_name__					:       Tuple    							=							val[-dim:]

								else:
												__magic_name__					:       int    							=							val

				return orig_state_dict



def     _UpperCamelCase				(			UpperCamelCase__  , UpperCamelCase__		):






				"""simple docstring"""



				__magic_name__					:       Optional[int]    							=							ViTMAEConfig()
				if "large" in checkpoint_url:
								__magic_name__					:       List[Any]    							=							1024
								__magic_name__					:       List[Any]    							=							4096
								__magic_name__					:       Tuple    							=							24
								__magic_name__					:       str    							=							16
				elif "huge" in checkpoint_url:
								__magic_name__					:       List[str]    							=							14
								__magic_name__					:       List[Any]    							=							1280
								__magic_name__					:       int    							=							5120
								__magic_name__					:       Any    							=							32
								__magic_name__					:       List[Any]    							=							16

				__magic_name__					:       int    							=							ViTMAEForPreTraining(UpperCamelCase__		)

				__magic_name__					:       Tuple    							=							torch.hub.load_state_dict_from_url(UpperCamelCase__  , map_location="cpu"		)["model"]

				__magic_name__					:       Any    							=							ViTMAEImageProcessor(size=config.image_size		)

				__magic_name__					:       List[str]    							=							convert_state_dict(UpperCamelCase__  , UpperCamelCase__		)

				model.load_state_dict(UpperCamelCase__		)
				model.eval()

				__magic_name__					:       Optional[int]    							=							"https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg"

				__magic_name__					:       List[str]    							=							Image.open(requests.get(UpperCamelCase__  , stream=UpperCamelCase__		).raw		)
				__magic_name__					:       List[str]    							=							ViTMAEImageProcessor(size=config.image_size		)
				__magic_name__					:       Dict    							=							image_processor(images=UpperCamelCase__  , return_tensors="pt"		)

				# forward pass
				torch.manual_seed(2		)
				__magic_name__					:       Optional[int]    							=							model(**UpperCamelCase__		)
				__magic_name__					:       Union[str, Any]    							=							outputs.logits

				if "large" in checkpoint_url:
								__magic_name__					:       Any    							=							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:
								__magic_name__					:       Optional[Any]    							=							torch.tensor(
								    [[-1.1599, -0.9199, -1.2221], [-1.1952, -0.9269, -1.2307], [-1.2143, -0.9337, -1.2262]]		)
				else:
								__magic_name__					:       Optional[Any]    							=							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__":
		_SCREAMING_SNAKE_CASE							: 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."
		)

		_SCREAMING_SNAKE_CASE							: List[Any]										=			parser.parse_args()
		convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)

from __future__ import annotations


def    a      ( a	)     ->float:




			'''simple docstring'''


			SCREAMING_SNAKE_CASE     						= 0.00
			SCREAMING_SNAKE_CASE     						= 0
			for resistor in resistors:
						if resistor <= 0:
									SCREAMING_SNAKE_CASE     						= F"""Resistor at index {index} has a negative or zero value!"""
									raise ValueError(a	)
						first_sum += 1 / float(a	)
						index += 1
			return 1 / first_sum


def    a      ( a	)     ->float:




			'''simple docstring'''


			SCREAMING_SNAKE_CASE     						= 0.00
			SCREAMING_SNAKE_CASE     						= 0
			for resistor in resistors:
						sum_r += resistor
						if resistor < 0:
									SCREAMING_SNAKE_CASE     						= F"""Resistor at index {index} has a negative value!"""
									raise ValueError(a	)
						index += 1
			return sum_r


if __name__ == "__main__":
							import doctest

							doctest.testmod()