




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      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[Any]					):
					__lowerCAmelCase           =	[2, 2, 6, 2] if "tiny" in model_name else [2, 2, 18, 2]
					__lowerCAmelCase           =	True if "large" in model_name or "huge" in model_name else False
					__lowerCAmelCase           =	True if "large" in model_name or "huge" in model_name else False
					__lowerCAmelCase           =	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:
															__lowerCAmelCase           =	[3, 3, 3, 3]
															__lowerCAmelCase           =	[5, 5, 5, 5]
										elif "fl4" in model_name:
															__lowerCAmelCase           =	[4, 4, 4, 4]
															__lowerCAmelCase           =	[3, 3, 3, 3]

					if "tiny" in model_name or "small" in model_name or "base" in model_name:
										__lowerCAmelCase           =	[3, 3, 3, 3]
										if "lrf" in model_name:
															__lowerCAmelCase           =	[3, 3, 3, 3]
										else:
															__lowerCAmelCase           =	[2, 2, 2, 2]

					if "tiny" in model_name:
										__lowerCAmelCase           =	96
					elif "small" in model_name:
										__lowerCAmelCase           =	96
					elif "base" in model_name:
										__lowerCAmelCase           =	1_28
					elif "large" in model_name:
										__lowerCAmelCase           =	1_92
					elif "xlarge" in model_name:
										__lowerCAmelCase           =	2_56
					elif "huge" in model_name:
										__lowerCAmelCase           =	3_52

					# set label information
					__lowerCAmelCase           =	"huggingface/label-files"
					if "large" in model_name or "huge" in model_name:
										__lowerCAmelCase           =	"imagenet-22k-id2label.json"
					else:
										__lowerCAmelCase           =	"imagenet-1k-id2label.json"

					__lowerCAmelCase           =	json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE_				,				SCREAMING_SNAKE_CASE_				,				repo_type="dataset"					)				,				"r"					)					)
					__lowerCAmelCase           =	{int(SCREAMING_SNAKE_CASE_					): v for k, v in idalabel.items()}
					__lowerCAmelCase           =	{v: k for k, v in idalabel.items()}

					__lowerCAmelCase           =	FocalNetConfig(
					    embed_dim=SCREAMING_SNAKE_CASE_				,				depths=SCREAMING_SNAKE_CASE_				,				focal_levels=SCREAMING_SNAKE_CASE_				,				focal_windows=SCREAMING_SNAKE_CASE_				,				use_conv_embed=SCREAMING_SNAKE_CASE_				,				idalabel=SCREAMING_SNAKE_CASE_				,				labelaid=SCREAMING_SNAKE_CASE_				,				use_post_layernorm=SCREAMING_SNAKE_CASE_				,				use_layerscale=SCREAMING_SNAKE_CASE_				,				)

					return config







def      _a				(						SCREAMING_SNAKE_CASE_							:    Union[str, Any]					):
					if "patch_embed.proj" in name:
										__lowerCAmelCase           =	name.replace("patch_embed.proj"				,				"embeddings.patch_embeddings.projection"					)
					if "patch_embed.norm" in name:
										__lowerCAmelCase           =	name.replace("patch_embed.norm"				,				"embeddings.norm"					)
					if "layers" in name:
										__lowerCAmelCase           =	"encoder." + name
					if "encoder.layers" in name:
										__lowerCAmelCase           =	name.replace("encoder.layers"				,				"encoder.stages"					)
					if "downsample.proj" in name:
										__lowerCAmelCase           =	name.replace("downsample.proj"				,				"downsample.projection"					)
					if "blocks" in name:
										__lowerCAmelCase           =	name.replace("blocks"				,				"layers"					)
					if "modulation.f.weight" in name or "modulation.f.bias" in name:
										__lowerCAmelCase           =	name.replace("modulation.f"				,				"modulation.projection_in"					)
					if "modulation.h.weight" in name or "modulation.h.bias" in name:
										__lowerCAmelCase           =	name.replace("modulation.h"				,				"modulation.projection_context"					)
					if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
										__lowerCAmelCase           =	name.replace("modulation.proj"				,				"modulation.projection_out"					)

					if name == "norm.weight":
										__lowerCAmelCase           =	"layernorm.weight"
					if name == "norm.bias":
										__lowerCAmelCase           =	"layernorm.bias"

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

					return name







def      _a				(						SCREAMING_SNAKE_CASE_							:    Optional[int]				,				SCREAMING_SNAKE_CASE_							:    List[Any]				,				SCREAMING_SNAKE_CASE_							:    Optional[Any]=False					):
					# fmt: off
					__lowerCAmelCase           =	{
					    "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

					__lowerCAmelCase           =	model_name_to_url[model_name]
					print("Checkpoint URL: "				,				SCREAMING_SNAKE_CASE_					)
					__lowerCAmelCase           =	torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE_				,				map_location="cpu"					)["model"]

					# rename keys
					for key in state_dict.copy().keys():
										__lowerCAmelCase           =	state_dict.pop(SCREAMING_SNAKE_CASE_					)
										__lowerCAmelCase           =	val

					__lowerCAmelCase           =	get_focalnet_config(SCREAMING_SNAKE_CASE_					)
					__lowerCAmelCase           =	FocalNetForImageClassification(SCREAMING_SNAKE_CASE_					)
					model.eval()

					# load state dict
					model.load_state_dict(SCREAMING_SNAKE_CASE_					)

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

					__lowerCAmelCase           =	BitImageProcessor(
					    do_resize=SCREAMING_SNAKE_CASE_				,				size={"shortest_edge": 2_56}				,				resample=PILImageResampling.BILINEAR				,				do_center_crop=SCREAMING_SNAKE_CASE_				,				crop_size=2_24				,				do_normalize=SCREAMING_SNAKE_CASE_				,				image_mean=SCREAMING_SNAKE_CASE_				,				image_std=SCREAMING_SNAKE_CASE_				,				)
					__lowerCAmelCase           =	Image.open(requests.get(SCREAMING_SNAKE_CASE_				,				stream=SCREAMING_SNAKE_CASE_					).raw					)
					__lowerCAmelCase           =	processor(images=SCREAMING_SNAKE_CASE_				,				return_tensors="pt"					)

					__lowerCAmelCase           =	transforms.Compose(
					    [
					        transforms.Resize(2_56					),
					        transforms.CenterCrop(2_24					),
					        transforms.ToTensor(),
					        transforms.Normalize(mean=[0.4_85, 0.4_56, 0.4_06]				,				std=[0.2_29, 0.2_24, 0.2_25]					),
					    ]					)

					__lowerCAmelCase           =	image_transforms(SCREAMING_SNAKE_CASE_					).unsqueeze(0					)

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

					__lowerCAmelCase           =	model(**SCREAMING_SNAKE_CASE_					)

					__lowerCAmelCase           =	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":
										__lowerCAmelCase           =	torch.tensor([0.21_66, -0.43_68, 0.21_91]					)
					elif model_name == "focalnet-tiny-lrf":
										__lowerCAmelCase           =	torch.tensor([1.16_69, 0.01_25, -0.16_95]					)
					elif model_name == "focalnet-small":
										__lowerCAmelCase           =	torch.tensor([0.49_17, -0.04_30, 0.13_41]					)
					elif model_name == "focalnet-small-lrf":
										__lowerCAmelCase           =	torch.tensor([-0.25_88, -0.53_42, -0.23_31]					)
					elif model_name == "focalnet-base":
										__lowerCAmelCase           =	torch.tensor([-0.16_55, -0.40_90, -0.17_30]					)
					elif model_name == "focalnet-base-lrf":
										__lowerCAmelCase           =	torch.tensor([0.53_06, -0.04_83, -0.39_28]					)
					assert torch.allclose(outputs.logits[0, :3]				,				SCREAMING_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(SCREAMING_SNAKE_CASE_					)
										processor.save_pretrained(SCREAMING_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__":
					UpperCamelCase__         =      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.""",
					)

					UpperCamelCase__         =      parser.parse_args()
					convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)










UpperCamelCase__         =      """0.18.2"""

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
					if not is_onnx_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_onnx_objects import *  # noqa F403
else:
					from .pipelines import OnnxRuntimeModel

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_pt_objects import *  # noqa F403
else:
					from .models import (
					    AutoencoderKL,
					    ControlNetModel,
					    ModelMixin,
					    PriorTransformer,
					    TaFilmDecoder,
					    TransformeraDModel,
					    UNetaDModel,
					    UNetaDConditionModel,
					    UNetaDModel,
					    UNetaDConditionModel,
					    VQModel,
					)
					from .optimization import (
					    get_constant_schedule,
					    get_constant_schedule_with_warmup,
					    get_cosine_schedule_with_warmup,
					    get_cosine_with_hard_restarts_schedule_with_warmup,
					    get_linear_schedule_with_warmup,
					    get_polynomial_decay_schedule_with_warmup,
					    get_scheduler,
					)
					from .pipelines import (
					    AudioPipelineOutput,
					    ConsistencyModelPipeline,
					    DanceDiffusionPipeline,
					    DDIMPipeline,
					    DDPMPipeline,
					    DiffusionPipeline,
					    DiTPipeline,
					    ImagePipelineOutput,
					    KarrasVePipeline,
					    LDMPipeline,
					    LDMSuperResolutionPipeline,
					    PNDMPipeline,
					    RePaintPipeline,
					    ScoreSdeVePipeline,
					)
					from .schedulers import (
					    CMStochasticIterativeScheduler,
					    DDIMInverseScheduler,
					    DDIMParallelScheduler,
					    DDIMScheduler,
					    DDPMParallelScheduler,
					    DDPMScheduler,
					    DEISMultistepScheduler,
					    DPMSolverMultistepInverseScheduler,
					    DPMSolverMultistepScheduler,
					    DPMSolverSinglestepScheduler,
					    EulerAncestralDiscreteScheduler,
					    EulerDiscreteScheduler,
					    HeunDiscreteScheduler,
					    IPNDMScheduler,
					    KarrasVeScheduler,
					    KDPMaAncestralDiscreteScheduler,
					    KDPMaDiscreteScheduler,
					    PNDMScheduler,
					    RePaintScheduler,
					    SchedulerMixin,
					    ScoreSdeVeScheduler,
					    UnCLIPScheduler,
					    UniPCMultistepScheduler,
					    VQDiffusionScheduler,
					)
					from .training_utils import EMAModel

try:
					if not (is_torch_available() and is_scipy_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
					from .schedulers import LMSDiscreteScheduler

try:
					if not (is_torch_available() and is_torchsde_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
					from .schedulers import DPMSolverSDEScheduler

try:
					if not (is_torch_available() and is_transformers_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
					from .pipelines import (
					    AltDiffusionImgaImgPipeline,
					    AltDiffusionPipeline,
					    AudioLDMPipeline,
					    CycleDiffusionPipeline,
					    IFImgaImgPipeline,
					    IFImgaImgSuperResolutionPipeline,
					    IFInpaintingPipeline,
					    IFInpaintingSuperResolutionPipeline,
					    IFPipeline,
					    IFSuperResolutionPipeline,
					    ImageTextPipelineOutput,
					    KandinskyImgaImgPipeline,
					    KandinskyInpaintPipeline,
					    KandinskyPipeline,
					    KandinskyPriorPipeline,
					    KandinskyVaaControlnetImgaImgPipeline,
					    KandinskyVaaControlnetPipeline,
					    KandinskyVaaImgaImgPipeline,
					    KandinskyVaaInpaintPipeline,
					    KandinskyVaaPipeline,
					    KandinskyVaaPriorEmbaEmbPipeline,
					    KandinskyVaaPriorPipeline,
					    LDMTextToImagePipeline,
					    PaintByExamplePipeline,
					    SemanticStableDiffusionPipeline,
					    ShapEImgaImgPipeline,
					    ShapEPipeline,
					    StableDiffusionAttendAndExcitePipeline,
					    StableDiffusionControlNetImgaImgPipeline,
					    StableDiffusionControlNetInpaintPipeline,
					    StableDiffusionControlNetPipeline,
					    StableDiffusionDepthaImgPipeline,
					    StableDiffusionDiffEditPipeline,
					    StableDiffusionImageVariationPipeline,
					    StableDiffusionImgaImgPipeline,
					    StableDiffusionInpaintPipeline,
					    StableDiffusionInpaintPipelineLegacy,
					    StableDiffusionInstructPixaPixPipeline,
					    StableDiffusionLatentUpscalePipeline,
					    StableDiffusionLDMaDPipeline,
					    StableDiffusionModelEditingPipeline,
					    StableDiffusionPanoramaPipeline,
					    StableDiffusionParadigmsPipeline,
					    StableDiffusionPipeline,
					    StableDiffusionPipelineSafe,
					    StableDiffusionPixaPixZeroPipeline,
					    StableDiffusionSAGPipeline,
					    StableDiffusionUpscalePipeline,
					    StableUnCLIPImgaImgPipeline,
					    StableUnCLIPPipeline,
					    TextToVideoSDPipeline,
					    TextToVideoZeroPipeline,
					    UnCLIPImageVariationPipeline,
					    UnCLIPPipeline,
					    UniDiffuserModel,
					    UniDiffuserPipeline,
					    UniDiffuserTextDecoder,
					    VersatileDiffusionDualGuidedPipeline,
					    VersatileDiffusionImageVariationPipeline,
					    VersatileDiffusionPipeline,
					    VersatileDiffusionTextToImagePipeline,
					    VideoToVideoSDPipeline,
					    VQDiffusionPipeline,
					)

try:
					if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
					from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
					if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
					from .pipelines import StableDiffusionKDiffusionPipeline

try:
					if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
					from .pipelines import (
					    OnnxStableDiffusionImgaImgPipeline,
					    OnnxStableDiffusionInpaintPipeline,
					    OnnxStableDiffusionInpaintPipelineLegacy,
					    OnnxStableDiffusionPipeline,
					    OnnxStableDiffusionUpscalePipeline,
					    StableDiffusionOnnxPipeline,
					)

try:
					if not (is_torch_available() and is_librosa_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
					from .pipelines import AudioDiffusionPipeline, Mel

try:
					if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
					from .pipelines import SpectrogramDiffusionPipeline

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_flax_objects import *  # noqa F403
else:
					from .models.controlnet_flax import FlaxControlNetModel
					from .models.modeling_flax_utils import FlaxModelMixin
					from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
					from .models.vae_flax import FlaxAutoencoderKL
					from .pipelines import FlaxDiffusionPipeline
					from .schedulers import (
					    FlaxDDIMScheduler,
					    FlaxDDPMScheduler,
					    FlaxDPMSolverMultistepScheduler,
					    FlaxKarrasVeScheduler,
					    FlaxLMSDiscreteScheduler,
					    FlaxPNDMScheduler,
					    FlaxSchedulerMixin,
					    FlaxScoreSdeVeScheduler,
					)


try:
					if not (is_flax_available() and is_transformers_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
					from .pipelines import (
					    FlaxStableDiffusionControlNetPipeline,
					    FlaxStableDiffusionImgaImgPipeline,
					    FlaxStableDiffusionInpaintPipeline,
					    FlaxStableDiffusionPipeline,
					)

try:
					if not (is_note_seq_available()):
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					from .utils.dummy_note_seq_objects import *  # noqa F403
else:
					from .pipelines import MidiProcessor




