




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

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

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

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

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

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

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

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

			return name
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE=False   ):
			'''simple docstring'''
			# fmt: off
			SCREAMING_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

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

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

			SCREAMING_SNAKE_CASE           =					get_focalnet_config(SCREAMING_SNAKE_CASE   )
			SCREAMING_SNAKE_CASE           =					FocalNetForImageClassification(SCREAMING_SNAKE_CASE   )
			model.eval()

			# load state dict
			model.load_state_dict(SCREAMING_SNAKE_CASE   )

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

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

			SCREAMING_SNAKE_CASE           =					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]   ),
			    ]   )

			SCREAMING_SNAKE_CASE           =					image_transforms(SCREAMING_SNAKE_CASE   ).unsqueeze(0   )

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

			SCREAMING_SNAKE_CASE           =					model(**SCREAMING_SNAKE_CASE   )

			SCREAMING_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":
						SCREAMING_SNAKE_CASE           =					torch.tensor([0.2_166, -0.4_368, 0.2_191]   )
			elif model_name == "focalnet-tiny-lrf":
						SCREAMING_SNAKE_CASE           =					torch.tensor([1.1_669, 0.0_125, -0.1_695]   )
			elif model_name == "focalnet-small":
						SCREAMING_SNAKE_CASE           =					torch.tensor([0.4_917, -0.0_430, 0.1_341]   )
			elif model_name == "focalnet-small-lrf":
						SCREAMING_SNAKE_CASE           =					torch.tensor([-0.2_588, -0.5_342, -0.2_331]   )
			elif model_name == "focalnet-base":
						SCREAMING_SNAKE_CASE           =					torch.tensor([-0.1_655, -0.4_090, -0.1_730]   )
			elif model_name == "focalnet-base-lrf":
						SCREAMING_SNAKE_CASE           =					torch.tensor([0.5_306, -0.0_483, -0.3_928]   )
			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__":
		__A						:							Tuple							=  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)












import os
import shutil
from pathlib import Path
from typing import Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging


if is_onnx_available():
		import onnxruntime as ort


__A						:							str							=  logging.get_logger(__name__)

__A						:							str							=  {
    """tensor(bool)""": np.bool_,
    """tensor(int8)""": np.inta,
    """tensor(uint8)""": np.uinta,
    """tensor(int16)""": np.intaa,
    """tensor(uint16)""": np.uintaa,
    """tensor(int32)""": np.intaa,
    """tensor(uint32)""": np.uintaa,
    """tensor(int64)""": np.intaa,
    """tensor(uint64)""": np.uintaa,
    """tensor(float16)""": np.floataa,
    """tensor(float)""": np.floataa,
    """tensor(double)""": np.floataa,
}




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	List[str]       ,     a       :	Tuple=None       ,     **a       :	Any			)			->					List[str]:
										logger.info("""`diffusers.OnnxRuntimeModel` is experimental and might change in the future."""			)
										SCREAMING_SNAKE_CASE           =					model
										SCREAMING_SNAKE_CASE           =					kwargs.get("""model_save_dir"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					kwargs.get("""latest_model_name"""       ,     a			)





							def __call__(					self       :	List[str]       ,     **a       :	Any			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					{k: np.array(a			) for k, v in kwargs.items()}
										return self.model.run(a       ,     a			)





							@staticmethod
							def    _UpperCAmelCase     (					a       :	Union[str, Path]       ,     a       :	Any=None       ,     a       :	Optional[int]=None			)			->					Optional[Any]:
										if provider is None:
													logger.info("""No onnxruntime provider specified, using CPUExecutionProvider"""			)
													SCREAMING_SNAKE_CASE           =					"""CPUExecutionProvider"""

										return ort.InferenceSession(a       ,     providers=[provider]       ,     sess_options=a			)





							def    _UpperCAmelCase     (					self       :	str       ,     a       :	Union[str, Path]       ,     a       :	Optional[str] = None       ,     **a       :	str			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					file_name if file_name is not None else ONNX_WEIGHTS_NAME

										SCREAMING_SNAKE_CASE           =					self.model_save_dir.joinpath(self.latest_model_name			)
										SCREAMING_SNAKE_CASE           =					Path(a			).joinpath(a			)
										try:
													shutil.copyfile(a       ,     a			)
										except shutil.SameFileError:
													pass

										# copy external weights (for models >2GB)
										SCREAMING_SNAKE_CASE           =					self.model_save_dir.joinpath(a			)
										if src_path.exists():
													SCREAMING_SNAKE_CASE           =					Path(a			).joinpath(a			)
													try:
																shutil.copyfile(a       ,     a			)
													except shutil.SameFileError:
																pass





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Union[str, os.PathLike]       ,     **a       :	Tuple       ,     )			->					str:
										if os.path.isfile(a			):
													logger.error(f"""Provided path ({save_directory}) should be a directory, not a file"""			)
													return

										os.makedirs(a       ,     exist_ok=a			)

										# saving model weights/files
										self._save_pretrained(a       ,     **a			)





							@classmethod
							def    _UpperCAmelCase     (					cls       :	List[Any]       ,     a       :	Union[str, Path]       ,     a       :	Optional[Union[bool, str, None]] = None       ,     a       :	Optional[Union[str, None]] = None       ,     a       :	bool = False       ,     a       :	Optional[str] = None       ,     a       :	Optional[str] = None       ,     a       :	Optional[str] = None       ,     a       :	Optional["ort.SessionOptions"] = None       ,     **a       :	Union[str, Any]       ,     )			->					List[str]:
										SCREAMING_SNAKE_CASE           =					file_name if file_name is not None else ONNX_WEIGHTS_NAME
										# load model from local directory
										if os.path.isdir(a			):
													SCREAMING_SNAKE_CASE           =					OnnxRuntimeModel.load_model(
													    os.path.join(a       ,     a			)       ,     provider=a       ,     sess_options=a			)
													SCREAMING_SNAKE_CASE           =					Path(a			)
										# load model from hub
										else:
													# download model
													SCREAMING_SNAKE_CASE           =					hf_hub_download(
													    repo_id=a       ,     filename=a       ,     use_auth_token=a       ,     revision=a       ,     cache_dir=a       ,     force_download=a       ,     )
													SCREAMING_SNAKE_CASE           =					Path(a			).parent
													SCREAMING_SNAKE_CASE           =					Path(a			).name
													SCREAMING_SNAKE_CASE           =					OnnxRuntimeModel.load_model(a       ,     provider=a       ,     sess_options=a			)
										return cls(model=a       ,     **a			)







							@classmethod
							def    _UpperCAmelCase     (					cls       :	List[Any]       ,     a       :	Union[str, Path]       ,     a       :	bool = True       ,     a       :	Optional[str] = None       ,     a       :	Optional[str] = None       ,     **a       :	Union[str, Any]       ,     )			->					Any:
										SCREAMING_SNAKE_CASE           =					None
										if len(str(a			).split("""@"""			)			) == 2:
													SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					model_id.split("""@"""			)

										return cls._from_pretrained(
										    model_id=a       ,     revision=a       ,     cache_dir=a       ,     force_download=a       ,     use_auth_token=a       ,     **a       ,     )






