






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

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

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

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

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

							snake_case__	  =       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   (	a						:	Tuple ):
							if "patch_embed.proj" in name:
														snake_case__	  =       name.replace("""patch_embed.proj"""  ,					"""embeddings.patch_embeddings.projection""" )
							if "patch_embed.norm" in name:
														snake_case__	  =       name.replace("""patch_embed.norm"""  ,					"""embeddings.norm""" )
							if "layers" in name:
														snake_case__	  =       """encoder.""" + name
							if "encoder.layers" in name:
														snake_case__	  =       name.replace("""encoder.layers"""  ,					"""encoder.stages""" )
							if "downsample.proj" in name:
														snake_case__	  =       name.replace("""downsample.proj"""  ,					"""downsample.projection""" )
							if "blocks" in name:
														snake_case__	  =       name.replace("""blocks"""  ,					"""layers""" )
							if "modulation.f.weight" in name or "modulation.f.bias" in name:
														snake_case__	  =       name.replace("""modulation.f"""  ,					"""modulation.projection_in""" )
							if "modulation.h.weight" in name or "modulation.h.bias" in name:
														snake_case__	  =       name.replace("""modulation.h"""  ,					"""modulation.projection_context""" )
							if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
														snake_case__	  =       name.replace("""modulation.proj"""  ,					"""modulation.projection_out""" )

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

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

							return name

def _UpperCAmelCase   (	a						:	List[Any]  ,					a						:	Optional[int]  ,					a						:	List[str]=False ):
							# fmt: off
							snake_case__	  =       {
							    """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

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

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

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

							# load state dict
							model.load_state_dict(_lowerCAmelCase )

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

							snake_case__	  =       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  ,					)
							snake_case__	  =       Image.open(requests.get(_lowerCAmelCase  ,					stream=_lowerCAmelCase ).raw )
							snake_case__	  =       processor(images=_lowerCAmelCase  ,					return_tensors="""pt""" )

							snake_case__	  =       transforms.Compose(
							    [
							        transforms.Resize(256 ),
							        transforms.CenterCrop(224 ),
							        transforms.ToTensor(),
							        transforms.Normalize(mean=[0.485, 0.456, 0.406]  ,					std=[0.229, 0.224, 0.225] ),
							    ] )

							snake_case__	  =       image_transforms(_lowerCAmelCase ).unsqueeze(0 )

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

							snake_case__	  =       model(**_lowerCAmelCase )

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


a__       =     {
    """configuration_lilt""": ["""LILT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LiltConfig"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     [
	    """LILT_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """LiltForQuestionAnswering""",
	    """LiltForSequenceClassification""",
	    """LiltForTokenClassification""",
	    """LiltModel""",
	    """LiltPreTrainedModel""",
	]

if TYPE_CHECKING:
	from .configuration_lilt import LILT_PRETRAINED_CONFIG_ARCHIVE_MAP, LiltConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_lilt import (
		    LILT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    LiltForQuestionAnswering,
		    LiltForSequenceClassification,
		    LiltForTokenClassification,
		    LiltModel,
		    LiltPreTrainedModel,
		)

else:
	import sys

	a__       =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
