





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

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

				if "tiny" in model_name:
								__a :						Dict			       =  96
				elif "small" in model_name:
								__a :						Any			       =  96
				elif "base" in model_name:
								__a :						Union[str, Any]			       =  1_28
				elif "large" in model_name:
								__a :						List[Any]			       =  1_92
				elif "xlarge" in model_name:
								__a :						List[Any]			       =  2_56
				elif "huge" in model_name:
								__a :						Optional[Any]			       =  3_52

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

				__a :						Tuple			       =  json.load(open(hf_hub_download(a_   ,       a_   ,       repo_type='''dataset''')   ,       '''r'''))
				__a :						Dict			       =  {int(a_): v for k, v in idalabel.items()}
				__a :						Optional[Any]			       =  {v: k for k, v in idalabel.items()}

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

				if name == "norm.weight":
								__a :						Tuple			       =  '''layernorm.weight'''
				if name == "norm.bias":
								__a :						List[Any]			       =  '''layernorm.bias'''

				if "head" in name:
								__a :						List[Any]			       =  name.replace('''head'''   ,       '''classifier''')
				else:
								__a :						Tuple			       =  '''focalnet.''' + name

				return name

def     __A      (			a_						:Any   ,       a_						:Optional[int]   ,       a_						:Union[str, Any]=False)		->		Union[str, Any]:
				# fmt: off
				__a :						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

				__a :						Optional[int]			       =  model_name_to_url[model_name]
				print('''Checkpoint URL: '''   ,       a_)
				__a :						List[Any]			       =  torch.hub.load_state_dict_from_url(a_   ,       map_location='''cpu''')['''model''']

				# rename keys
				for key in state_dict.copy().keys():
								__a :						Union[str, Any]			       =  state_dict.pop(a_)
								__a :						Union[str, Any]			       =  val

				__a :						Optional[int]			       =  get_focalnet_config(a_)
				__a :						Union[str, Any]			       =  FocalNetForImageClassification(a_)
				model.eval()

				# load state dict
				model.load_state_dict(a_)

				# verify conversion
				__a :						Dict			       =  '''http://images.cocodataset.org/val2017/000000039769.jpg'''

				__a :						Tuple			       =  BitImageProcessor(
				    do_resize=a_   ,       size={'''shortest_edge''': 2_56}   ,       resample=PILImageResampling.BILINEAR   ,       do_center_crop=a_   ,       crop_size=2_24   ,       do_normalize=a_   ,       image_mean=a_   ,       image_std=a_   ,       )
				__a :						Dict			       =  Image.open(requests.get(a_   ,       stream=a_).raw)
				__a :						Union[str, Any]			       =  processor(images=a_   ,       return_tensors='''pt''')

				__a :						Dict			       =  transforms.Compose(
				    [
				        transforms.Resize(2_56),
				        transforms.CenterCrop(2_24),
				        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]),
				    ])

				__a :						List[str]			       =  image_transforms(a_).unsqueeze(0)

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

				__a :						Optional[Any]			       =  model(**a_)

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






"""simple docstring"""






from math import isqrt, loga

def     __A      (			a_						:int)		->		list[int]:
				__a :						int			       =  [True] * max_number
				for i in range(2   ,       isqrt(max_number - 1) + 1):
								if is_prime[i]:
												for j in range(i**2   ,       a_   ,       a_):
																__a :						int			       =  False

				return [i for i in range(2   ,       a_) if is_prime[i]]

def     __A      (			a_						:int = 80_08_00   ,       a_						:int = 80_08_00)		->		int:
				__a :						str			       =  degree * loga(a_)
				__a :						Tuple			       =  int(a_)
				__a :						int			       =  calculate_prime_numbers(a_)

				__a :						List[Any]			       =  0
				__a :						Optional[Any]			       =  0
				__a :						Dict			       =  len(a_) - 1
				while left < right:
								while (
								    prime_numbers[right] * loga(prime_numbers[left])
								    + prime_numbers[left] * loga(prime_numbers[right])
								    > upper_bound
								):
												right -= 1
								hybrid_integers_count += right - left
								left += 1

				return hybrid_integers_count


if __name__ == "__main__":
		print(F'{solution() = }')