

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        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__      )  ->					Any:
	__lowerCamelCase    :    Optional[int] 	=			[2, 2, 6, 2] if 'tiny' in model_name else [2, 2, 1_8, 2]
	__lowerCamelCase    :    Optional[int] 	=			True if 'large' in model_name or 'huge' in model_name else False
	__lowerCamelCase    :    Optional[int] 	=			True if 'large' in model_name or 'huge' in model_name else False
	__lowerCamelCase    :    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:
			__lowerCamelCase    :    Optional[int] 	=			[3, 3, 3, 3]
			__lowerCamelCase    :    int 	=			[5, 5, 5, 5]
		elif "fl4" in model_name:
			__lowerCamelCase    :    List[str] 	=			[4, 4, 4, 4]
			__lowerCamelCase    :    Any 	=			[3, 3, 3, 3]

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

	if "tiny" in model_name:
		__lowerCamelCase    :    Optional[int] 	=			9_6
	elif "small" in model_name:
		__lowerCamelCase    :    List[Any] 	=			9_6
	elif "base" in model_name:
		__lowerCamelCase    :    Union[str, Any] 	=			1_2_8
	elif "large" in model_name:
		__lowerCamelCase    :    Tuple 	=			1_9_2
	elif "xlarge" in model_name:
		__lowerCamelCase    :    Optional[Any] 	=			2_5_6
	elif "huge" in model_name:
		__lowerCamelCase    :    Optional[Any] 	=			3_5_2

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

	__lowerCamelCase    :    Optional[int] 	=			json.load(open(hf_hub_download(lowerCamelCase__     ,			lowerCamelCase__     ,			repo_type='dataset'      )     ,			'r'      )      )
	__lowerCamelCase    :    List[Any] 	=			{int(lowerCamelCase__      ): v for k, v in idalabel.items()}
	__lowerCamelCase    :    Any 	=			{v: k for k, v in idalabel.items()}

	__lowerCamelCase    :    str 	=			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        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__      )  ->					int:
	if "patch_embed.proj" in name:
		__lowerCamelCase    :    List[str] 	=			name.replace('patch_embed.proj'     ,			'embeddings.patch_embeddings.projection'      )
	if "patch_embed.norm" in name:
		__lowerCamelCase    :    Dict 	=			name.replace('patch_embed.norm'     ,			'embeddings.norm'      )
	if "layers" in name:
		__lowerCamelCase    :    Any 	=			'encoder.' + name
	if "encoder.layers" in name:
		__lowerCamelCase    :    Dict 	=			name.replace('encoder.layers'     ,			'encoder.stages'      )
	if "downsample.proj" in name:
		__lowerCamelCase    :    Optional[Any] 	=			name.replace('downsample.proj'     ,			'downsample.projection'      )
	if "blocks" in name:
		__lowerCamelCase    :    Optional[Any] 	=			name.replace('blocks'     ,			'layers'      )
	if "modulation.f.weight" in name or "modulation.f.bias" in name:
		__lowerCamelCase    :    Optional[int] 	=			name.replace('modulation.f'     ,			'modulation.projection_in'      )
	if "modulation.h.weight" in name or "modulation.h.bias" in name:
		__lowerCamelCase    :    Optional[Any] 	=			name.replace('modulation.h'     ,			'modulation.projection_context'      )
	if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
		__lowerCamelCase    :    List[str] 	=			name.replace('modulation.proj'     ,			'modulation.projection_out'      )

	if name == "norm.weight":
		__lowerCamelCase    :    Any 	=			'layernorm.weight'
	if name == "norm.bias":
		__lowerCamelCase    :    str 	=			'layernorm.bias'

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

	return name






def        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__     ,			lowerCamelCase__     ,			lowerCamelCase__=False      )  ->					Dict:
	# fmt: off
	__lowerCamelCase    :    Optional[Any] 	=			{
	    '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    :    str 	=			model_name_to_url[model_name]
	print('Checkpoint URL: '     ,			lowerCamelCase__      )
	__lowerCamelCase    :    Union[str, Any] 	=			torch.hub.load_state_dict_from_url(lowerCamelCase__     ,			map_location='cpu'      )['model']

	# rename keys
	for key in state_dict.copy().keys():
		__lowerCamelCase    :    Dict 	=			state_dict.pop(lowerCamelCase__      )
		__lowerCamelCase    :    Optional[Any] 	=			val

	__lowerCamelCase    :    List[Any] 	=			get_focalnet_config(lowerCamelCase__      )
	__lowerCamelCase    :    int 	=			FocalNetForImageClassification(lowerCamelCase__      )
	model.eval()

	# load state dict
	model.load_state_dict(lowerCamelCase__      )

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

	__lowerCamelCase    :    Dict 	=			BitImageProcessor(
	    do_resize=lowerCamelCase__     ,			size={'shortest_edge': 2_5_6}     ,			resample=PILImageResampling.BILINEAR     ,			do_center_crop=lowerCamelCase__     ,			crop_size=2_2_4     ,			do_normalize=lowerCamelCase__     ,			image_mean=lowerCamelCase__     ,			image_std=lowerCamelCase__     ,			)
	__lowerCamelCase    :    Dict 	=			Image.open(requests.get(lowerCamelCase__     ,			stream=lowerCamelCase__      ).raw      )
	__lowerCamelCase    :    str 	=			processor(images=lowerCamelCase__     ,			return_tensors='pt'      )

	__lowerCamelCase    :    Optional[Any] 	=			transforms.Compose(
	    [
	        transforms.Resize(2_5_6      ),
	        transforms.CenterCrop(2_2_4      ),
	        transforms.ToTensor(),
	        transforms.Normalize(mean=[0.485, 0.456, 0.406]     ,			std=[0.229, 0.224, 0.225]      ),
	    ]      )

	__lowerCamelCase    :    str 	=			image_transforms(lowerCamelCase__      ).unsqueeze(0      )

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

	__lowerCamelCase    :    List[Any] 	=			model(**lowerCamelCase__      )

	__lowerCamelCase    :    List[Any] 	=			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    :    str 	=			torch.tensor([0.2166, -0.4368, 0.2191]      )
	elif model_name == "focalnet-tiny-lrf":
		__lowerCamelCase    :    Dict 	=			torch.tensor([1.1669, 0.0125, -0.1695]      )
	elif model_name == "focalnet-small":
		__lowerCamelCase    :    Any 	=			torch.tensor([0.4917, -0.0430, 0.1341]      )
	elif model_name == "focalnet-small-lrf":
		__lowerCamelCase    :    Any 	=			torch.tensor([-0.2588, -0.5342, -0.2331]      )
	elif model_name == "focalnet-base":
		__lowerCamelCase    :    Optional[int] 	=			torch.tensor([-0.1655, -0.4090, -0.1730]      )
	elif model_name == "focalnet-base-lrf":
		__lowerCamelCase    :    Optional[Any] 	=			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 collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean






def        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__      )  ->					List[Any]:

	# A local function to see if a dot lands in the circle.
	def is_in_circle(lowerCamelCase__     ,			lowerCamelCase__      ) -> bool:
		__lowerCamelCase    :    Dict 	=			sqrt((x**2) + (y**2)      )
		# Our circle has a radius of 1, so a distance
		# greater than 1 would land outside the circle.
		return distance_from_centre <= 1

	# The proportion of guesses that landed in the circle
	__lowerCamelCase    :    Optional[int] 	=			mean(
	    int(is_in_circle(uniform(-1.0     ,			1.0      )     ,			uniform(-1.0     ,			1.0      )      )      )
	    for _ in range(lowerCamelCase__      )      )
	# The ratio of the area for circle to square is pi/4.
	__lowerCamelCase    :    Any 	=			proportion * 4
	print(F"The estimated value of pi is {pi_estimate}"      )
	print(F"The numpy value of pi is {pi}"      )
	print(F"The total error is {abs(pi - pi_estimate      )}"      )






def        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__     ,			lowerCamelCase__     ,			lowerCamelCase__ = 0.0     ,			lowerCamelCase__ = 1.0     ,			)  ->					float:
	return mean(
	    function_to_integrate(uniform(lowerCamelCase__     ,			lowerCamelCase__      )      ) for _ in range(lowerCamelCase__      )      ) * (max_value - min_value)






def        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__     ,			lowerCamelCase__ = 0.0     ,			lowerCamelCase__ = 1.0      )  ->					None:

	def identity_function(lowerCamelCase__      ) -> float:
		return x

	__lowerCamelCase    :    str 	=			area_under_curve_estimator(
	    lowerCamelCase__     ,			lowerCamelCase__     ,			lowerCamelCase__     ,			lowerCamelCase__      )
	__lowerCamelCase    :    int 	=			(max_value * max_value - min_value * min_value) / 2

	print('******************'      )
	print(F"Estimating area under y=x where x varies from {min_value} to {max_value}"      )
	print(F"Estimated value is {estimated_value}"      )
	print(F"Expected value is {expected_value}"      )
	print(F"Total error is {abs(estimated_value - expected_value      )}"      )
	print('******************'      )






def        SCREAMING_SNAKE_CASE__	(  lowerCamelCase__      )  ->					None:

	def function_to_integrate(lowerCamelCase__      ) -> float:
		return sqrt(4.0 - x * x      )

	__lowerCamelCase    :    Any 	=			area_under_curve_estimator(
	    lowerCamelCase__     ,			lowerCamelCase__     ,			0.0     ,			2.0      )

	print('******************'      )
	print('Estimating pi using area_under_curve_estimator'      )
	print(F"Estimated value is {estimated_value}"      )
	print(F"Expected value is {pi}"      )
	print(F"Total error is {abs(estimated_value - pi      )}"      )
	print('******************'      )


if __name__ == "__main__":
					import doctest

					doctest.testmod()




