
"""simple docstring"""




import argparse
import json

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

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling


def   __magic_name__	(      __snake_case				:       List[str]  ) ->				str:
       lowercase    :				str       		=							[2, 2, 6, 2] if "tiny" in model_name else [2, 2, 18, 2]
       lowercase    :				List[str]       		=							True if "large" in model_name or "huge" in model_name else False
       lowercase    :				str       		=							True if "large" in model_name or "huge" in model_name else False
       lowercase    :				List[str]       		=							True if "large" in model_name or "huge" in model_name else False

       if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
              if "fl3" in model_name:
                     lowercase    :				str       		=							[3, 3, 3, 3]
                     lowercase    :				Union[str, Any]       		=							[5, 5, 5, 5]
              elif "fl4" in model_name:
                     lowercase    :				str       		=							[4, 4, 4, 4]
                     lowercase    :				str       		=							[3, 3, 3, 3]

       if "tiny" in model_name or "small" in model_name or "base" in model_name:
              lowercase    :				List[Any]       		=							[3, 3, 3, 3]
              if "lrf" in model_name:
                     lowercase    :				List[str]       		=							[3, 3, 3, 3]
              else:
                     lowercase    :				Tuple       		=							[2, 2, 2, 2]

       if "tiny" in model_name:
              lowercase    :				List[Any]       		=							96
       elif "small" in model_name:
              lowercase    :				Dict       		=							96
       elif "base" in model_name:
              lowercase    :				str       		=							128
       elif "large" in model_name:
              lowercase    :				Dict       		=							192
       elif "xlarge" in model_name:
              lowercase    :				List[Any]       		=							256
       elif "huge" in model_name:
              lowercase    :				int       		=							352

       # set label information
       lowercase    :				List[str]       		=							"huggingface/label-files"
       if "large" in model_name or "huge" in model_name:
              lowercase    :				Any       		=							"imagenet-22k-id2label.json"
       else:
              lowercase    :				int       		=							"imagenet-1k-id2label.json"

       lowercase    :				Any       		=							json.load(open(hf_hub_download(__snake_case     , __snake_case     , repo_type="dataset"  )     , "r"  )  )
       lowercase    :				Optional[int]       		=							{int(__snake_case  ): v for k, v in idalabel.items()}
       lowercase    :				List[Any]       		=							{v: k for k, v in idalabel.items()}

       lowercase    :				Any       		=							FocalNetConfig(
           embed_dim=__snake_case     , depths=__snake_case     , focal_levels=__snake_case     , focal_windows=__snake_case     , use_conv_embed=__snake_case     , idalabel=__snake_case     , labelaid=__snake_case     , use_post_layernorm=__snake_case     , use_layerscale=__snake_case     , )

       return config


def   __magic_name__	(      __snake_case				:       Optional[int]  ) ->				List[Any]:
       if "patch_embed.proj" in name:
              lowercase    :				Any       		=							name.replace("patch_embed.proj"     , "embeddings.patch_embeddings.projection"  )
       if "patch_embed.norm" in name:
              lowercase    :				List[str]       		=							name.replace("patch_embed.norm"     , "embeddings.norm"  )
       if "layers" in name:
              lowercase    :				Optional[Any]       		=							"encoder." + name
       if "encoder.layers" in name:
              lowercase    :				Dict       		=							name.replace("encoder.layers"     , "encoder.stages"  )
       if "downsample.proj" in name:
              lowercase    :				Union[str, Any]       		=							name.replace("downsample.proj"     , "downsample.projection"  )
       if "blocks" in name:
              lowercase    :				Optional[int]       		=							name.replace("blocks"     , "layers"  )
       if "modulation.f.weight" in name or "modulation.f.bias" in name:
              lowercase    :				Union[str, Any]       		=							name.replace("modulation.f"     , "modulation.projection_in"  )
       if "modulation.h.weight" in name or "modulation.h.bias" in name:
              lowercase    :				int       		=							name.replace("modulation.h"     , "modulation.projection_context"  )
       if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
              lowercase    :				Union[str, Any]       		=							name.replace("modulation.proj"     , "modulation.projection_out"  )

       if name == "norm.weight":
              lowercase    :				Optional[Any]       		=							"layernorm.weight"
       if name == "norm.bias":
              lowercase    :				Dict       		=							"layernorm.bias"

       if "head" in name:
              lowercase    :				Any       		=							name.replace("head"     , "classifier"  )
       else:
              lowercase    :				str       		=							"focalnet." + name

       return name


def   __magic_name__	(      __snake_case				:       Optional[Any]     , __snake_case				:       Optional[int]     , __snake_case				:       str=False  ) ->				Dict:
       # fmt: off
       lowercase    :				int       		=							{
           "focalnet-tiny": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth",
           "focalnet-tiny-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth",
           "focalnet-small": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth",
           "focalnet-small-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth",
           "focalnet-base": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth",
           "focalnet-base-lrf": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth",
           "focalnet-large-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth",
           "focalnet-large-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth",
           "focalnet-xlarge-lrf-fl3": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth",
           "focalnet-xlarge-lrf-fl4": "https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth",
       }
       # fmt: on

       lowercase    :				Optional[int]       		=							model_name_to_url[model_name]
       print("Checkpoint URL: "     , __snake_case  )
       lowercase    :				List[str]       		=							torch.hub.load_state_dict_from_url(__snake_case     , map_location="cpu"  )["model"]

       # rename keys
       for key in state_dict.copy().keys():
              lowercase    :				Optional[Any]       		=							state_dict.pop(__snake_case  )
              lowercase    :				Union[str, Any]       		=							val

       lowercase    :				Optional[Any]       		=							get_focalnet_config(__snake_case  )
       lowercase    :				Optional[int]       		=							FocalNetForImageClassification(__snake_case  )
       model.eval()

       # load state dict
       model.load_state_dict(__snake_case  )

       # verify conversion
       lowercase    :				int       		=							"http://images.cocodataset.org/val2017/000000039769.jpg"

       lowercase    :				Dict       		=							BitImageProcessor(
           do_resize=__snake_case     , size={"shortest_edge": 256}     , resample=PILImageResampling.BILINEAR     , do_center_crop=__snake_case     , crop_size=224     , do_normalize=__snake_case     , image_mean=__snake_case     , image_std=__snake_case     , )
       lowercase    :				Dict       		=							Image.open(requests.get(__snake_case     , stream=__snake_case  ).raw  )
       lowercase    :				Optional[int]       		=							processor(images=__snake_case     , return_tensors="pt"  )

       lowercase    :				Optional[Any]       		=							transforms.Compose(
           [
               transforms.Resize(256  ),
               transforms.CenterCrop(224  ),
               transforms.ToTensor(),
               transforms.Normalize(mean=[0.4_85, 0.4_56, 0.4_06]     , std=[0.2_29, 0.2_24, 0.2_25]  ),
           ]  )

       lowercase    :				int       		=							image_transforms(__snake_case  ).unsqueeze(0  )

       # verify pixel_values
       assert torch.allclose(inputs.pixel_values     , __snake_case     , atol=1E-4  )

       lowercase    :				Optional[Any]       		=							model(**__snake_case  )

       lowercase    :				Tuple       		=							outputs.logits.argmax(-1  ).item()
       print("Predicted class:"     , model.config.idalabel[predicted_class_idx]  )

       print("First values of logits:"     , outputs.logits[0, :3]  )

       if model_name == "focalnet-tiny":
              lowercase    :				Union[str, Any]       		=							torch.tensor([0.21_66, -0.43_68, 0.21_91]  )
       elif model_name == "focalnet-tiny-lrf":
              lowercase    :				Optional[Any]       		=							torch.tensor([1.16_69, 0.01_25, -0.16_95]  )
       elif model_name == "focalnet-small":
              lowercase    :				Optional[Any]       		=							torch.tensor([0.49_17, -0.04_30, 0.13_41]  )
       elif model_name == "focalnet-small-lrf":
              lowercase    :				List[Any]       		=							torch.tensor([-0.25_88, -0.53_42, -0.23_31]  )
       elif model_name == "focalnet-base":
              lowercase    :				Optional[int]       		=							torch.tensor([-0.16_55, -0.40_90, -0.17_30]  )
       elif model_name == "focalnet-base-lrf":
              lowercase    :				Union[str, Any]       		=							torch.tensor([0.53_06, -0.04_83, -0.39_28]  )
       assert torch.allclose(outputs.logits[0, :3]     , __snake_case     , atol=1E-4  )
       print("Looks ok!"  )

       if pytorch_dump_folder_path is not None:
              print(f"""Saving model and processor of {model_name} to {pytorch_dump_folder_path}"""  )
              model.save_pretrained(__snake_case  )
              processor.save_pretrained(__snake_case  )

       if push_to_hub:
              print(f"""Pushing model and processor of {model_name} to the hub..."""  )
              model.push_to_hub(f"""{model_name}"""  )
              processor.push_to_hub(f"""{model_name}"""  )


if __name__ == "__main__":
   _A			:       int   		=       argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--model_name""",
       default="""focalnet-tiny""",
       type=str,
       help="""Name of the FocalNet model you'd like to convert.""",
   )
   parser.add_argument(
       """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
   )
   parser.add_argument(
       """--push_to_hub""",
       action="""store_true""",
       help="""Whether to push the model and processor to the hub.""",
   )

   _A			:       Optional[int]   		=       parser.parse_args()
   convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




"""simple docstring"""




from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


_A			:       int   		=       """CompVis/stable-diffusion-v1-1"""
_A			:       Any   		=       """CompVis/stable-diffusion-v1-2"""
_A			:       Optional[int]   		=       """CompVis/stable-diffusion-v1-3"""
_A			:       Union[str, Any]   		=       """CompVis/stable-diffusion-v1-4"""

class 		a__						(      a_						):
   def __init__(			self	,    _a	,    _a	,    _a	,    _a	,    _a	,    _a	,    _a	,    _a = True	,    ):
          super()._init_()

          lowercase    :				Optional[Any]       		=							StableDiffusionPipeline.from_pretrained(_a				)
          lowercase    :				str       		=							StableDiffusionPipeline.from_pretrained(_a				)
          lowercase    :				Dict       		=							StableDiffusionPipeline.from_pretrained(_a				)
          lowercase    :				Union[str, Any]       		=							StableDiffusionPipeline(
              vae=_a	,    text_encoder=_a	,    tokenizer=_a	,    unet=_a	,    scheduler=_a	,    safety_checker=_a	,    feature_extractor=_a	,    requires_safety_checker=_a	,    )

          self.register_modules(pipelinea=self.pipea	,    pipelinea=self.pipea	,    pipelinea=self.pipea	,    pipelinea=self.pipea				)
   @property
   def 			__magic_name__			(			self				):
          return {k: getattr(self	,    _a				) for k in self.config.keys() if not k.startswith("_"				)}
   def 			__magic_name__			(			self	,    _a = "auto"				):
          if slice_size == "auto":
                 # half the attention head size is usually a good trade-off between
                 # speed and memory
                 lowercase    :				str       		=							self.unet.config.attention_head_dim // 2
          self.unet.set_attention_slice(_a				)
   def 			__magic_name__			(			self				):
          self.enable_attention_slicing(_a				)
   @torch.no_grad()
   def 			__magic_name__			(			self	,    _a	,    _a = 512	,    _a = 512	,    _a = 50	,    _a = 7.5	,    _a = None	,    _a = 1	,    _a = 0.0	,    _a = None	,    _a = None	,    _a = "pil"	,    _a = True	,    _a = None	,    _a = 1	,    **_a	,    ):
          return self.pipea(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )
   @torch.no_grad()
   def 			__magic_name__			(			self	,    _a	,    _a = 512	,    _a = 512	,    _a = 50	,    _a = 7.5	,    _a = None	,    _a = 1	,    _a = 0.0	,    _a = None	,    _a = None	,    _a = "pil"	,    _a = True	,    _a = None	,    _a = 1	,    **_a	,    ):
          return self.pipea(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )
   @torch.no_grad()
   def 			__magic_name__			(			self	,    _a	,    _a = 512	,    _a = 512	,    _a = 50	,    _a = 7.5	,    _a = None	,    _a = 1	,    _a = 0.0	,    _a = None	,    _a = None	,    _a = "pil"	,    _a = True	,    _a = None	,    _a = 1	,    **_a	,    ):
          return self.pipea(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )
   @torch.no_grad()
   def 			__magic_name__			(			self	,    _a	,    _a = 512	,    _a = 512	,    _a = 50	,    _a = 7.5	,    _a = None	,    _a = 1	,    _a = 0.0	,    _a = None	,    _a = None	,    _a = "pil"	,    _a = True	,    _a = None	,    _a = 1	,    **_a	,    ):
          return self.pipea(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )

   @torch.no_grad()
   def 			__magic_name__			(			self	,    _a	,    _a = 512	,    _a = 512	,    _a = 50	,    _a = 7.5	,    _a = None	,    _a = 1	,    _a = 0.0	,    _a = None	,    _a = None	,    _a = "pil"	,    _a = True	,    _a = None	,    _a = 1	,    **_a	,    ):
          lowercase    :				List[Any]       		=							"cuda" if torch.cuda.is_available() else "cpu"
          self.to(_a				)

          # Checks if the height and width are divisible by 8 or not
          if height % 8 != 0 or width % 8 != 0:
                 raise ValueError(f"""`height` and `width` must be divisible by 8 but are {height} and {width}."""				)

          # Get first result from Stable Diffusion Checkpoint v1.1
          lowercase    :				List[Any]       		=							self.textaimg_sda_a(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )

          # Get first result from Stable Diffusion Checkpoint v1.2
          lowercase    :				Any       		=							self.textaimg_sda_a(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )

          # Get first result from Stable Diffusion Checkpoint v1.3
          lowercase    :				str       		=							self.textaimg_sda_a(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )

          # Get first result from Stable Diffusion Checkpoint v1.4
          lowercase    :				Optional[int]       		=							self.textaimg_sda_a(
              prompt=_a	,    height=_a	,    width=_a	,    num_inference_steps=_a	,    guidance_scale=_a	,    negative_prompt=_a	,    num_images_per_prompt=_a	,    eta=_a	,    generator=_a	,    latents=_a	,    output_type=_a	,    return_dict=_a	,    callback=_a	,    callback_steps=_a	,    **_a	,    )

          # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
          return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]				)


