



'''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]				):
							SCREAMING_SNAKE_CASE					:      List[Any]     					=			[2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 18, 2]
							SCREAMING_SNAKE_CASE					:      Dict     					=			True if '''large''' in model_name or '''huge''' in model_name else False
							SCREAMING_SNAKE_CASE					:      int     					=			True if '''large''' in model_name or '''huge''' in model_name else False
							SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			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					:      int     					=			[3, 3, 3, 3]
																					SCREAMING_SNAKE_CASE					:      Tuple     					=			[5, 5, 5, 5]
														elif "fl4" in model_name:
																					SCREAMING_SNAKE_CASE					:      Dict     					=			[4, 4, 4, 4]
																					SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[3, 3, 3, 3]

							if "tiny" in model_name or "small" in model_name or "base" in model_name:
														SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[3, 3, 3, 3]
														if "lrf" in model_name:
																					SCREAMING_SNAKE_CASE					:      Tuple     					=			[3, 3, 3, 3]
														else:
																					SCREAMING_SNAKE_CASE					:      int     					=			[2, 2, 2, 2]

							if "tiny" in model_name:
														SCREAMING_SNAKE_CASE					:      Optional[int]     					=			96
							elif "small" in model_name:
														SCREAMING_SNAKE_CASE					:      List[str]     					=			96
							elif "base" in model_name:
														SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			128
							elif "large" in model_name:
														SCREAMING_SNAKE_CASE					:      int     					=			192
							elif "xlarge" in model_name:
														SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			256
							elif "huge" in model_name:
														SCREAMING_SNAKE_CASE					:      Dict     					=			352

							# set label information
							SCREAMING_SNAKE_CASE					:      Any     					=			'''huggingface/label-files'''
							if "large" in model_name or "huge" in model_name:
														SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			'''imagenet-22k-id2label.json'''
							else:
														SCREAMING_SNAKE_CASE					:      Any     					=			'''imagenet-1k-id2label.json'''

							SCREAMING_SNAKE_CASE					:      Dict     					=			json.load(open(hf_hub_download(A					,		A					,		repo_type='''dataset'''				)					,		'''r'''				)				)
							SCREAMING_SNAKE_CASE					:      List[str]     					=			{int(A				): v for k, v in idalabel.items()}
							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			{v: k for k, v in idalabel.items()}

							SCREAMING_SNAKE_CASE					:      str     					=			FocalNetConfig(
							    embed_dim=A					,		depths=A					,		focal_levels=A					,		focal_windows=A					,		use_conv_embed=A					,		idalabel=A					,		labelaid=A					,		use_post_layernorm=A					,		use_layerscale=A					,		)

							return config
def 					UpperCAmelCase   (						A  :				int				):
							if "patch_embed.proj" in name:
														SCREAMING_SNAKE_CASE					:      int     					=			name.replace('''patch_embed.proj'''					,		'''embeddings.patch_embeddings.projection'''				)
							if "patch_embed.norm" in name:
														SCREAMING_SNAKE_CASE					:      List[Any]     					=			name.replace('''patch_embed.norm'''					,		'''embeddings.norm'''				)
							if "layers" in name:
														SCREAMING_SNAKE_CASE					:      Tuple     					=			'''encoder.''' + name
							if "encoder.layers" in name:
														SCREAMING_SNAKE_CASE					:      str     					=			name.replace('''encoder.layers'''					,		'''encoder.stages'''				)
							if "downsample.proj" in name:
														SCREAMING_SNAKE_CASE					:      List[str]     					=			name.replace('''downsample.proj'''					,		'''downsample.projection'''				)
							if "blocks" in name:
														SCREAMING_SNAKE_CASE					:      str     					=			name.replace('''blocks'''					,		'''layers'''				)
							if "modulation.f.weight" in name or "modulation.f.bias" in name:
														SCREAMING_SNAKE_CASE					:      Tuple     					=			name.replace('''modulation.f'''					,		'''modulation.projection_in'''				)
							if "modulation.h.weight" in name or "modulation.h.bias" in name:
														SCREAMING_SNAKE_CASE					:      str     					=			name.replace('''modulation.h'''					,		'''modulation.projection_context'''				)
							if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
														SCREAMING_SNAKE_CASE					:      Optional[int]     					=			name.replace('''modulation.proj'''					,		'''modulation.projection_out'''				)

							if name == "norm.weight":
														SCREAMING_SNAKE_CASE					:      str     					=			'''layernorm.weight'''
							if name == "norm.bias":
														SCREAMING_SNAKE_CASE					:      List[Any]     					=			'''layernorm.bias'''

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

							return name
def 					UpperCAmelCase   (						A  :				List[Any]					,		A  :				Optional[int]					,		A  :				Any=False				):
							# fmt: off
							SCREAMING_SNAKE_CASE					:      int     					=			{
							    '''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					:      Any     					=			model_name_to_url[model_name]
							print('''Checkpoint URL: '''					,		A				)
							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			torch.hub.load_state_dict_from_url(A					,		map_location='''cpu'''				)['''model''']

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

							SCREAMING_SNAKE_CASE					:      Dict     					=			get_focalnet_config(A				)
							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			FocalNetForImageClassification(A				)
							model.eval()

							# load state dict
							model.load_state_dict(A				)

							# verify conversion
							SCREAMING_SNAKE_CASE					:      List[str]     					=			'''http://images.cocodataset.org/val2017/000000039769.jpg'''

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

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

							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			image_transforms(A				).unsqueeze(0				)

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

							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			model(**A				)

							SCREAMING_SNAKE_CASE					:      int     					=			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					:      Dict     					=			torch.tensor([0.2166, -0.4368, 0.2191]				)
							elif model_name == "focalnet-tiny-lrf":
														SCREAMING_SNAKE_CASE					:      str     					=			torch.tensor([1.1669, 0.0125, -0.1695]				)
							elif model_name == "focalnet-small":
														SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			torch.tensor([0.4917, -0.0430, 0.1341]				)
							elif model_name == "focalnet-small-lrf":
														SCREAMING_SNAKE_CASE					:      str     					=			torch.tensor([-0.2588, -0.5342, -0.2331]				)
							elif model_name == "focalnet-base":
														SCREAMING_SNAKE_CASE					:      Optional[int]     					=			torch.tensor([-0.1655, -0.4090, -0.1730]				)
							elif model_name == "focalnet-base-lrf":
														SCREAMING_SNAKE_CASE					:      Tuple     					=			torch.tensor([0.5306, -0.0483, -0.3928]				)
							assert torch.allclose(outputs.logits[0, :3]					,		A					,		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(A				)
														processor.save_pretrained(A				)

							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_     :       str								=						parser.parse_args()
							convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









'''simple docstring'''



from bisect import bisect
from itertools import accumulate
def 					UpperCAmelCase   (						A  :				Tuple					,		A  :				Optional[Any]					,		A  :				Dict					,		A  :				Any				):
							SCREAMING_SNAKE_CASE					:      List[str]     					=			sorted(zip(A					,		A				)					,		key=lambda A				: x[0] / x[1]					,		reverse=A				)
							SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					:      Dict     					=			[i[0] for i in r], [i[1] for i in r]
							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			list(accumulate(A				)				)
							SCREAMING_SNAKE_CASE					:      List[Any]     					=			bisect(A					,		A				)
							return (
							    0
							    if k == 0
							    else sum(vl[:k]				) + (w - acc[k - 1]) * (vl[k]) / (wt[k])
							    if k != n
							    else sum(vl[:k]				)
							)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




