






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

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

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

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

						A__  :					Optional[Any]											=					json.load(open(hf_hub_download(UpperCAmelCase__,  UpperCAmelCase__,  repo_type="""dataset""" ),  """r""" ) )
						A__  :					Union[str, Any]											=					{int(UpperCAmelCase__ ): v for k, v in idalabel.items()}
						A__  :					List[str]											=					{v: k for k, v in idalabel.items()}

						A__  :					Any											=					FocalNetConfig(
						    embed_dim=UpperCAmelCase__,  depths=UpperCAmelCase__,  focal_levels=UpperCAmelCase__,  focal_windows=UpperCAmelCase__,  use_conv_embed=UpperCAmelCase__,  idalabel=UpperCAmelCase__,  labelaid=UpperCAmelCase__,  use_post_layernorm=UpperCAmelCase__,  use_layerscale=UpperCAmelCase__,  )

						return config




def        _lowerCAmelCase						(							UpperCAmelCase__    :   List[Any] )						->Optional[int]:
						if "patch_embed.proj" in name:
												A__  :					Union[str, Any]											=					name.replace("""patch_embed.proj""",  """embeddings.patch_embeddings.projection""" )
						if "patch_embed.norm" in name:
												A__  :					Union[str, Any]											=					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__  :					Union[str, Any]											=					name.replace("""downsample.proj""",  """downsample.projection""" )
						if "blocks" in name:
												A__  :					Any											=					name.replace("""blocks""",  """layers""" )
						if "modulation.f.weight" in name or "modulation.f.bias" in name:
												A__  :					Optional[int]											=					name.replace("""modulation.f""",  """modulation.projection_in""" )
						if "modulation.h.weight" in name or "modulation.h.bias" in name:
												A__  :					str											=					name.replace("""modulation.h""",  """modulation.projection_context""" )
						if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
												A__  :					int											=					name.replace("""modulation.proj""",  """modulation.projection_out""" )

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

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

						return name




def        _lowerCAmelCase						(							UpperCAmelCase__    :   Any,  UpperCAmelCase__    :   Dict,  UpperCAmelCase__    :   Optional[int]=False )						->int:
						# 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[Any]											=					model_name_to_url[model_name]
						print("""Checkpoint URL: """,  UpperCAmelCase__ )
						A__  :					Any											=					torch.hub.load_state_dict_from_url(UpperCAmelCase__,  map_location="""cpu""" )["""model"""]

						# rename keys
						for key in state_dict.copy().keys():
												A__  :					Any											=					state_dict.pop(UpperCAmelCase__ )
												A__  :					Optional[int]											=					val

						A__  :					Any											=					get_focalnet_config(UpperCAmelCase__ )
						A__  :					str											=					FocalNetForImageClassification(UpperCAmelCase__ )
						model.eval()

						# load state dict
						model.load_state_dict(UpperCAmelCase__ )

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

						A__  :					Union[str, Any]											=					BitImageProcessor(
						    do_resize=UpperCAmelCase__,  size={"""shortest_edge""": 2_5_6},  resample=PILImageResampling.BILINEAR,  do_center_crop=UpperCAmelCase__,  crop_size=2_2_4,  do_normalize=UpperCAmelCase__,  image_mean=UpperCAmelCase__,  image_std=UpperCAmelCase__,  )
						A__  :					Any											=					Image.open(requests.get(UpperCAmelCase__,  stream=UpperCAmelCase__ ).raw )
						A__  :					Optional[int]											=					processor(images=UpperCAmelCase__,  return_tensors="""pt""" )

						A__  :					Optional[int]											=					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] ),
						    ] )

						A__  :					int											=					image_transforms(UpperCAmelCase__ ).unsqueeze(0 )

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

						A__  :					List[Any]											=					model(**UpperCAmelCase__ )

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

						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 collections import defaultdict
from math import gcd




def        _lowerCAmelCase						(							UpperCAmelCase__    :   int = 1_5_0_0_0_0_0 )						->int:
						A__  :					defaultdict											=					defaultdict(UpperCAmelCase__ )
						A__  :					Any											=					2
						while 2 * euclid_m * (euclid_m + 1) <= limit:
												for euclid_n in range((euclid_m % 2) + 1,  UpperCAmelCase__,  2 ):
																		if gcd(UpperCAmelCase__,  UpperCAmelCase__ ) > 1:
																								continue
																		A__  :					str											=					2 * euclid_m * (euclid_m + euclid_n)
																		for perimeter in range(UpperCAmelCase__,  limit + 1,  UpperCAmelCase__ ):
																								frequencies[perimeter] += 1
												euclid_m += 1
						return sum(1 for frequency in frequencies.values() if frequency == 1 )


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






