





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__(__snake_case							)       ->   Optional[Any]:







	'''simple docstring'''







	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__              =	128
	elif "large" in model_name:
		lowerCamelCase__              =	192
	elif "xlarge" in model_name:
		lowerCamelCase__              =	256
	elif "huge" in model_name:
		lowerCamelCase__              =	352

	# 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 lowerCAmelCase__(__snake_case							)       ->   Optional[Any]:







	'''simple docstring'''







	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 lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case=False							)       ->   Optional[int]:







	'''simple docstring'''







	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''': 256} ,resample=PILImageResampling.BILINEAR ,do_center_crop=__snake_case ,crop_size=224 ,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(256							),
	        transforms.CenterCrop(224							),
	        transforms.ToTensor(),
	        transforms.Normalize(mean=[0.4_8_5, 0.4_5_6, 0.4_0_6] ,std=[0.2_2_9, 0.2_2_4, 0.2_2_5]							),
	    ]							)

	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.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]							)
	elif model_name == "focalnet-tiny-lrf":
		lowerCamelCase__              =	torch.tensor([1.1_6_6_9, 0.0_1_2_5, -0.1_6_9_5]							)
	elif model_name == "focalnet-small":
		lowerCamelCase__              =	torch.tensor([0.4_9_1_7, -0.0_4_3_0, 0.1_3_4_1]							)
	elif model_name == "focalnet-small-lrf":
		lowerCamelCase__              =	torch.tensor([-0.2_5_8_8, -0.5_3_4_2, -0.2_3_3_1]							)
	elif model_name == "focalnet-base":
		lowerCamelCase__              =	torch.tensor([-0.1_6_5_5, -0.4_0_9_0, -0.1_7_3_0]							)
	elif model_name == "focalnet-base-lrf":
		lowerCamelCase__              =	torch.tensor([0.5_3_0_6, -0.0_4_8_3, -0.3_9_2_8]							)
	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__":
			_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 math import sqrt





def lowerCAmelCase__(__snake_case							)       ->   bool:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (
	    number >= 0
	), "'number' must been an int and positive"

	lowerCamelCase__              =	True

	# 0 and 1 are none primes.
	if number <= 1:
		lowerCamelCase__              =	False

	for divisor in range(2 ,int(round(sqrt(__snake_case							)							)							) + 1							):
		# if 'number' divisible by 'divisor' then sets 'status'
		# of false and break up the loop.
		if number % divisor == 0:
			lowerCamelCase__              =	False
			break

    # precondition
	assert isinstance(__snake_case ,__snake_case							), "'status' must been from type bool"

	return status





def lowerCAmelCase__(__snake_case							)       ->   Any:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (n > 2), "'N' must been an int and > 2"

	# beginList: contains all natural numbers from 2 up to N
	lowerCamelCase__              =	list(range(2 ,n + 1							)							)

	lowerCamelCase__              =	[]  # this list will be returns.

	# actual sieve of erathostenes
	for i in range(len(__snake_case							)							):
		for j in range(i + 1 ,len(__snake_case							)							):
			if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
				lowerCamelCase__              =	0

    # filters actual prime numbers.
	lowerCamelCase__              =	[x for x in begin_list if x != 0]

	# precondition
	assert isinstance(__snake_case ,__snake_case							), "'ans' must been from type list"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   Optional[Any]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (n > 2), "'N' must been an int and > 2"

	lowerCamelCase__              =	[]

	# iterates over all numbers between 2 up to N+1
	# if a number is prime then appends to list 'ans'
	for number in range(2 ,n + 1							):
		if is_prime(__snake_case							):
			ans.append(__snake_case							)

    # precondition
	assert isinstance(__snake_case ,__snake_case							), "'ans' must been from type list"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   List[str]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and number >= 0, "'number' must been an int and >= 0"

	lowerCamelCase__              =	[]  # this list will be returns of the function.

	# potential prime number factors.

	lowerCamelCase__              =	2

	lowerCamelCase__              =	number

	if number == 0 or number == 1:
		ans.append(__snake_case							)

	# if 'number' not prime then builds the prime factorization of 'number'
	elif not is_prime(__snake_case							):
		while quotient != 1:
			if is_prime(__snake_case							) and (quotient % factor == 0):
				ans.append(__snake_case							)
				quotient /= factor
			else:
				factor += 1

	else:
		ans.append(__snake_case							)

	# precondition
	assert isinstance(__snake_case ,__snake_case							), "'ans' must been from type list"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   List[Any]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	lowerCamelCase__              =	0

	# prime factorization of 'number'
	lowerCamelCase__              =	prime_factorization(__snake_case							)

	lowerCamelCase__              =	max(__snake_case							)

	# precondition
	assert isinstance(__snake_case ,__snake_case							), "'ans' must been from type int"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   Dict:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (
	    number >= 0
	), "'number' bust been an int and >= 0"

	lowerCamelCase__              =	0

	# prime factorization of 'number'
	lowerCamelCase__              =	prime_factorization(__snake_case							)

	lowerCamelCase__              =	min(__snake_case							)

	# precondition
	assert isinstance(__snake_case ,__snake_case							), "'ans' must been from type int"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   List[Any]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							), "'number' must been an int"
	assert isinstance(number % 2 == 0 ,__snake_case							), "compare bust been from type bool"

	return number % 2 == 0





def lowerCAmelCase__(__snake_case							)       ->   List[str]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							), "'number' must been an int"
	assert isinstance(number % 2 != 0 ,__snake_case							), "compare bust been from type bool"

	return number % 2 != 0





def lowerCAmelCase__(__snake_case							)       ->   List[Any]:







	'''simple docstring'''







	assert (
	    isinstance(__snake_case ,__snake_case							) and (number > 2) and is_even(__snake_case							)
	), "'number' must been an int, even and > 2"

	lowerCamelCase__              =	[]  # this list will returned

	# creates a list of prime numbers between 2 up to 'number'
	lowerCamelCase__              =	get_prime_numbers(__snake_case							)
	lowerCamelCase__              =	len(__snake_case							)

	# run variable for while-loops.
	lowerCamelCase__              =	0
	lowerCamelCase__              =	None

	# exit variable. for break up the loops
	lowerCamelCase__              =	True

	while i < len_pn and loop:
		lowerCamelCase__              =	i + 1

		while j < len_pn and loop:
			if prime_numbers[i] + prime_numbers[j] == number:
				lowerCamelCase__              =	False
				ans.append(prime_numbers[i]							)
				ans.append(prime_numbers[j]							)

			j += 1

		i += 1

	# precondition
	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and (len(__snake_case							) == 2)
	    and (ans[0] + ans[1] == number)
	    and is_prime(ans[0]							)
	    and is_prime(ans[1]							)
	), "'ans' must contains two primes. And sum of elements must been eq 'number'"

	return ans





def lowerCAmelCase__(__snake_case ,__snake_case							)       ->   str:







	'''simple docstring'''







	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and isinstance(__snake_case ,__snake_case							)
	    and (numbera >= 0)
	    and (numbera >= 0)
	), "'number1' and 'number2' must been positive integer."

	lowerCamelCase__              =	0

	while numbera != 0:
		lowerCamelCase__              =	numbera % numbera
		lowerCamelCase__              =	numbera
		lowerCamelCase__              =	rest

	# precondition
	assert isinstance(__snake_case ,__snake_case							) and (
	    numbera >= 0
	), "'number' must been from type int and positive"

	return numbera





def lowerCAmelCase__(__snake_case ,__snake_case							)       ->   Any:







	'''simple docstring'''







	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and isinstance(__snake_case ,__snake_case							)
	    and (numbera >= 1)
	    and (numbera >= 1)
	), "'number1' and 'number2' must been positive integer."

	lowerCamelCase__              =	1  # actual answer that will be return.

	# for kgV (x,1)
	if numbera > 1 and numbera > 1:
		# builds the prime factorization of 'number1' and 'number2'
		lowerCamelCase__              =	prime_factorization(__snake_case							)
		lowerCamelCase__              =	prime_factorization(__snake_case							)

	elif numbera == 1 or numbera == 1:
		lowerCamelCase__              =	[]
		lowerCamelCase__              =	[]
		lowerCamelCase__              =	max(__snake_case ,__snake_case							)

	lowerCamelCase__              =	0
	lowerCamelCase__              =	0

	lowerCamelCase__              =	[]  # captured numbers int both 'primeFac1' and 'primeFac2'

	# iterates through primeFac1
	for n in prime_fac_a:
		if n not in done:
			if n in prime_fac_a:
				lowerCamelCase__              =	prime_fac_a.count(__snake_case							)
				lowerCamelCase__              =	prime_fac_a.count(__snake_case							)

				for _ in range(max(__snake_case ,__snake_case							)							):
					ans *= n

			else:
				lowerCamelCase__              =	prime_fac_a.count(__snake_case							)

				for _ in range(__snake_case							):
					ans *= n

			done.append(__snake_case							)

    # iterates through primeFac2
	for n in prime_fac_a:
		if n not in done:
			lowerCamelCase__              =	prime_fac_a.count(__snake_case							)

			for _ in range(__snake_case							):
				ans *= n

			done.append(__snake_case							)

    # precondition
	assert isinstance(__snake_case ,__snake_case							) and (
	    ans >= 0
	), "'ans' must been from type int and positive"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   Union[str, Any]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (n >= 0), "'number' must been a positive int"

	lowerCamelCase__              =	0
	lowerCamelCase__              =	2  # this variable holds the answer

	while index < n:
		index += 1

		ans += 1  # counts to the next number

		# if ans not prime then
		# runs to the next prime number.
		while not is_prime(__snake_case							):
			ans += 1

    # precondition
	assert isinstance(__snake_case ,__snake_case							) and is_prime(
	    __snake_case							), "'ans' must been a prime number and from type int"

	return ans





def lowerCAmelCase__(__snake_case ,__snake_case							)       ->   Dict:







	'''simple docstring'''







	assert (
	    is_prime(__snake_case							) and is_prime(__snake_case							) and (p_number_a < p_number_a)
	), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

	lowerCamelCase__              =	p_number_a + 1  # jump to the next number

	lowerCamelCase__              =	[]  # this list will be returns.

	# if number is not prime then
	# fetch the next prime number.
	while not is_prime(__snake_case							):
		number += 1

	while number < p_number_a:
		ans.append(__snake_case							)

		number += 1

		# fetch the next prime number.
		while not is_prime(__snake_case							):
			number += 1

    # precondition
	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and ans[0] != p_number_a
	    and ans[len(__snake_case							) - 1] != p_number_a
	), "'ans' must been a list without the arguments"

	# 'ans' contains not 'pNumber1' and 'pNumber2' !
	return ans





def lowerCAmelCase__(__snake_case							)       ->   Tuple:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (n >= 1), "'n' must been int and >= 1"

	lowerCamelCase__              =	[]  # will be returned.

	for divisor in range(1 ,n + 1							):
		if n % divisor == 0:
			ans.append(__snake_case							)

    # precondition
	assert ans[0] == 1 and ans[len(__snake_case							) - 1] == n, "Error in function getDivisiors(...)"

	return ans





def lowerCAmelCase__(__snake_case							)       ->   Optional[Any]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (
	    number > 1
	), "'number' must been an int and >= 1"

	lowerCamelCase__              =	get_divisors(__snake_case							)

	# precondition
	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and (divisors[0] == 1)
	    and (divisors[len(__snake_case							) - 1] == number)
	), "Error in help-function getDivisiors(...)"

	# summed all divisors up to 'number' (exclusive), hence [:-1]
	return sum(divisors[:-1]							) == number





def lowerCAmelCase__(__snake_case ,__snake_case							)       ->   Tuple:







	'''simple docstring'''







	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and isinstance(__snake_case ,__snake_case							)
	    and (denominator != 0)
	), "The arguments must been from type int and 'denominator' != 0"

	# build the greatest common divisor of numerator and denominator.
	lowerCamelCase__              =	gcd(abs(__snake_case							) ,abs(__snake_case							)							)

	# precondition
	assert (
	    isinstance(__snake_case ,__snake_case							)
	    and (numerator % gcd_of_fraction == 0)
	    and (denominator % gcd_of_fraction == 0)
	), "Error in function gcd(...,...)"

	return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)





def lowerCAmelCase__(__snake_case							)       ->   Optional[int]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (n >= 0), "'n' must been a int and >= 0"

	lowerCamelCase__              =	1  # this will be return.

	for factor in range(1 ,n + 1							):
		ans *= factor

	return ans





def lowerCAmelCase__(__snake_case							)       ->   Optional[Any]:







	'''simple docstring'''







	assert isinstance(__snake_case ,__snake_case							) and (n >= 0), "'n' must been an int and >= 0"

	lowerCamelCase__              =	0
	lowerCamelCase__              =	1
	lowerCamelCase__              =	1  # this will be return

	for _ in range(n - 1							):
		lowerCamelCase__              =	ans
		ans += fiba
		lowerCamelCase__              =	tmp

	return ans



