




"""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     a__ (				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(snake_case__       , snake_case__       , repo_type="""dataset"""				)       , """r"""				)				)
			lowerCamelCase			      =					{int(snake_case__				): v for k, v in idalabel.items()}
			lowerCamelCase			      =					{v: k for k, v in idalabel.items()}

			lowerCamelCase			      =					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     a__ (				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__ (				snake_case__       , snake_case__       , snake_case__=False				)						->					Any:
			# 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: """       , snake_case__				)
			lowerCamelCase			      =					torch.hub.load_state_dict_from_url(snake_case__       , map_location="""cpu"""				)["""model"""]

			# rename keys
			for key in state_dict.copy().keys():
						lowerCamelCase			      =					state_dict.pop(snake_case__				)
						lowerCamelCase			      =					val

			lowerCamelCase			      =					get_focalnet_config(snake_case__				)
			lowerCamelCase			      =					FocalNetForImageClassification(snake_case__				)
			model.eval()

			# load state dict
			model.load_state_dict(snake_case__				)

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

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

			lowerCamelCase			      =					transforms.Compose(
			    [
			        transforms.Resize(2_56				),
			        transforms.CenterCrop(2_24				),
			        transforms.ToTensor(),
			        transforms.Normalize(mean=[0.485, 0.456, 0.406]       , std=[0.229, 0.224, 0.225]				),
			    ]				)

			lowerCamelCase			      =					image_transforms(snake_case__				).unsqueeze(0				)

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

			lowerCamelCase			      =					model(**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.2166, -0.4368, 0.2191]				)
			elif model_name == "focalnet-tiny-lrf":
						lowerCamelCase			      =					torch.tensor([1.1669, 0.0125, -0.1695]				)
			elif model_name == "focalnet-small":
						lowerCamelCase			      =					torch.tensor([0.4917, -0.0430, 0.1341]				)
			elif model_name == "focalnet-small-lrf":
						lowerCamelCase			      =					torch.tensor([-0.2588, -0.5342, -0.2331]				)
			elif model_name == "focalnet-base":
						lowerCamelCase			      =					torch.tensor([-0.1655, -0.4090, -0.1730]				)
			elif model_name == "focalnet-base-lrf":
						lowerCamelCase			      =					torch.tensor([0.5306, -0.0483, -0.3928]				)
			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__":
					lowerCAmelCase							:			Dict     							=							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.""",
					)

					lowerCAmelCase							:			Union[str, Any]     							=							parser.parse_args()
					convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









"""simple docstring"""




def     a__ (				snake_case__       , snake_case__ = False				)						->					str:

			if not isinstance(snake_case__       , snake_case__				):
						lowerCamelCase			      =					F'Expected string as input, found {type(snake_case__				)}'
						raise ValueError(snake_case__				)
			if not isinstance(snake_case__       , snake_case__				):
						lowerCamelCase			      =					F'Expected boolean as use_pascal parameter, found {type(snake_case__				)}'
						raise ValueError(snake_case__				)

			lowerCamelCase			      =					input_str.split("""_"""				)

			lowerCamelCase			      =					0 if use_pascal else 1

			lowerCamelCase			      =					words[start_index:]

			lowerCamelCase			      =					[word[0].upper() + word[1:] for word in words_to_capitalize]

			lowerCamelCase			      =					"""""" if use_pascal else words[0]

			return "".join([initial_word, *capitalized_words]				)


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

					testmod()



