





import argparse

import requests
import torch
from PIL import Image

from transformers import ViTMAEConfig, ViTMAEForPreTraining, ViTMAEImageProcessor






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

     return name






def 							_lowerCAmelCase (  _a   :					str					,   _a   :					str			)	->			List[str]:
     for key in orig_state_dict.copy().keys():
          lowerCAmelCase_					:       Optional[int]    =		orig_state_dict.pop(_a			)

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

          else:
               lowerCAmelCase_					:       Tuple    =		val

     return orig_state_dict






def 							_lowerCAmelCase (  _a   :					Optional[Any]					,   _a   :					List[str]			)	->			Optional[int]:
     lowerCAmelCase_					:       List[Any]    =		ViTMAEConfig()
     if "large" in checkpoint_url:
          lowerCAmelCase_					:       int    =		10_24
          lowerCAmelCase_					:       Tuple    =		40_96
          lowerCAmelCase_					:       Tuple    =		24
          lowerCAmelCase_					:       Any    =		16
     elif "huge" in checkpoint_url:
          lowerCAmelCase_					:       List[Any]    =		14
          lowerCAmelCase_					:       Optional[Any]    =		12_80
          lowerCAmelCase_					:       Dict    =		51_20
          lowerCAmelCase_					:       int    =		32
          lowerCAmelCase_					:       Dict    =		16

     lowerCAmelCase_					:       Optional[Any]    =		ViTMAEForPreTraining(_a			)

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

     lowerCAmelCase_					:       List[Any]    =		ViTMAEImageProcessor(size=config.image_size			)

     lowerCAmelCase_					:       Any    =		convert_state_dict(_a					,   _a			)

     model.load_state_dict(_a			)
     model.eval()

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

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

     # forward pass
     torch.manual_seed(2			)
     lowerCAmelCase_					:       int    =		model(**_a			)
     lowerCAmelCase_					:       List[str]    =		outputs.logits

     if "large" in checkpoint_url:
          lowerCAmelCase_					:       int    =		torch.tensor(
              [[-0.7_309, -0.7_128, -1.0_169], [-1.0_161, -0.9_058, -1.1_878], [-1.0_478, -0.9_411, -1.1_911]]			)
     elif "huge" in checkpoint_url:
          lowerCAmelCase_					:       Optional[int]    =		torch.tensor(
              [[-1.1_599, -0.9_199, -1.2_221], [-1.1_952, -0.9_269, -1.2_307], [-1.2_143, -0.9_337, -1.2_262]]			)
     else:
          lowerCAmelCase_					:       str    =		torch.tensor(
              [[-0.9_192, -0.8_481, -1.1_259], [-1.1_349, -1.0_034, -1.2_599], [-1.1_757, -1.0_429, -1.2_726]]			)

     # 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__":
      UpperCAmelCase_					:   Optional[int] 							=						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."""
      )

      UpperCAmelCase_					:   List[str] 							=						parser.parse_args()
      convert_vit_mae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)












from collections.abc import Sequence






def 							_lowerCAmelCase (  _a   :					Sequence[float]					,   _a   :					bool = False			)	->			float:
     if not arr:
          return 0

     lowerCAmelCase_					:       List[str]    =		0 if allow_empty_subarrays else float("""-inf"""			)
     lowerCAmelCase_					:       List[Any]    =		0.0
     for num in arr:
          lowerCAmelCase_					:       int    =		max(0 if allow_empty_subarrays else num					,   curr_sum + num			)
          lowerCAmelCase_					:       List[str]    =		max(_a					,   _a			)

     return max_sum


if __name__ == "__main__":
      from doctest import testmod

      testmod()

      UpperCAmelCase_					:   int 							=						[-2, 1, -3, 4, -1, 2, 1, -5, 4]
      print(F"""{max_subarray_sum(nums) = }""")
