
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  UpperCamelCase					(							lowerCAmelCase__	):
					'''simple docstring'''
					lowercase					=		[2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 18, 2]
					lowercase					=		True if '''large''' in model_name or '''huge''' in model_name else False
					lowercase					=		True if '''large''' in model_name or '''huge''' in model_name else False
					lowercase					=		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					=		[3, 3, 3, 3]
															lowercase					=		[5, 5, 5, 5]
										elif "fl4" in model_name:
															lowercase					=		[4, 4, 4, 4]
															lowercase					=		[3, 3, 3, 3]

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

					if "tiny" in model_name:
										lowercase					=		96
					elif "small" in model_name:
										lowercase					=		96
					elif "base" in model_name:
										lowercase					=		128
					elif "large" in model_name:
										lowercase					=		192
					elif "xlarge" in model_name:
										lowercase					=		256
					elif "huge" in model_name:
										lowercase					=		352

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

					lowercase					=		json.load(open(hf_hub_download(lowerCAmelCase__				,    lowerCAmelCase__				,    repo_type='''dataset'''	)				,    '''r'''	)	)
					lowercase					=		{int(lowerCAmelCase__	): v for k, v in idalabel.items()}
					lowercase					=		{v: k for k, v in idalabel.items()}

					lowercase					=		FocalNetConfig(
					    embed_dim=lowerCAmelCase__				,    depths=lowerCAmelCase__				,    focal_levels=lowerCAmelCase__				,    focal_windows=lowerCAmelCase__				,    use_conv_embed=lowerCAmelCase__				,    idalabel=lowerCAmelCase__				,    labelaid=lowerCAmelCase__				,    use_post_layernorm=lowerCAmelCase__				,    use_layerscale=lowerCAmelCase__				,    )

					return config



def  UpperCamelCase					(							lowerCAmelCase__	):
					'''simple docstring'''
					if "patch_embed.proj" in name:
										lowercase					=		name.replace('''patch_embed.proj'''				,    '''embeddings.patch_embeddings.projection'''	)
					if "patch_embed.norm" in name:
										lowercase					=		name.replace('''patch_embed.norm'''				,    '''embeddings.norm'''	)
					if "layers" in name:
										lowercase					=		'''encoder.''' + name
					if "encoder.layers" in name:
										lowercase					=		name.replace('''encoder.layers'''				,    '''encoder.stages'''	)
					if "downsample.proj" in name:
										lowercase					=		name.replace('''downsample.proj'''				,    '''downsample.projection'''	)
					if "blocks" in name:
										lowercase					=		name.replace('''blocks'''				,    '''layers'''	)
					if "modulation.f.weight" in name or "modulation.f.bias" in name:
										lowercase					=		name.replace('''modulation.f'''				,    '''modulation.projection_in'''	)
					if "modulation.h.weight" in name or "modulation.h.bias" in name:
										lowercase					=		name.replace('''modulation.h'''				,    '''modulation.projection_context'''	)
					if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
										lowercase					=		name.replace('''modulation.proj'''				,    '''modulation.projection_out'''	)

					if name == "norm.weight":
										lowercase					=		'''layernorm.weight'''
					if name == "norm.bias":
										lowercase					=		'''layernorm.bias'''

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

					return name



def  UpperCamelCase					(							lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__=False	):
					'''simple docstring'''
					# fmt: off
					lowercase					=		{
					    '''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					=		model_name_to_url[model_name]
					print('''Checkpoint URL: '''				,    lowerCAmelCase__	)
					lowercase					=		torch.hub.load_state_dict_from_url(lowerCAmelCase__				,    map_location='''cpu'''	)['''model''']

					# rename keys
					for key in state_dict.copy().keys():
										lowercase					=		state_dict.pop(lowerCAmelCase__	)
										lowercase					=		val

					lowercase					=		get_focalnet_config(lowerCAmelCase__	)
					lowercase					=		FocalNetForImageClassification(lowerCAmelCase__	)
					model.eval()

					# load state dict
					model.load_state_dict(lowerCAmelCase__	)

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

					lowercase					=		BitImageProcessor(
					    do_resize=lowerCAmelCase__				,    size={'''shortest_edge''': 256}				,    resample=PILImageResampling.BILINEAR				,    do_center_crop=lowerCAmelCase__				,    crop_size=224				,    do_normalize=lowerCAmelCase__				,    image_mean=lowerCAmelCase__				,    image_std=lowerCAmelCase__				,    )
					lowercase					=		Image.open(requests.get(lowerCAmelCase__				,    stream=lowerCAmelCase__	).raw	)
					lowercase					=		processor(images=lowerCAmelCase__				,    return_tensors='''pt'''	)

					lowercase					=		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					=		image_transforms(lowerCAmelCase__	).unsqueeze(0	)

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

					lowercase					=		model(**lowerCAmelCase__	)

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

					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__":
							lowercase__	:Optional[Any]										=					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.",
							)

							lowercase__	:Any										=					parser.parse_args()
							convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__	:Tuple										=					{
    "configuration_instructblip": [
        "INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "InstructBlipConfig",
        "InstructBlipQFormerConfig",
        "InstructBlipVisionConfig",
    ],
    "processing_instructblip": ["InstructBlipProcessor"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase__	:List[str]										=					[
							    "INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "InstructBlipQFormerModel",
							    "InstructBlipPreTrainedModel",
							    "InstructBlipForConditionalGeneration",
							    "InstructBlipVisionModel",
							]

if TYPE_CHECKING:
							from .configuration_instructblip import (
							    INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    InstructBlipConfig,
							    InstructBlipQFormerConfig,
							    InstructBlipVisionConfig,
							)
							from .processing_instructblip import InstructBlipProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_instructblip import (
														    INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    InstructBlipForConditionalGeneration,
														    InstructBlipPreTrainedModel,
														    InstructBlipQFormerModel,
														    InstructBlipVisionModel,
														)

else:
							import sys

							lowercase__	:List[str]										=					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




