


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		(		_lowerCAmelCase							:   Any	):




 """simple docstring"""







 UpperCAmelCase__							 =						[2, 2, 6, 2] if "tiny" in model_name else [2, 2, 18, 2]
 UpperCAmelCase__							 =						True if "large" in model_name or "huge" in model_name else False
 UpperCAmelCase__							 =						True if "large" in model_name or "huge" in model_name else False
 UpperCAmelCase__							 =						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:
   UpperCAmelCase__							 =						[3, 3, 3, 3]
   UpperCAmelCase__							 =						[5, 5, 5, 5]
  elif "fl4" in model_name:
   UpperCAmelCase__							 =						[4, 4, 4, 4]
   UpperCAmelCase__							 =						[3, 3, 3, 3]

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

 if "tiny" in model_name:
  UpperCAmelCase__							 =						96
 elif "small" in model_name:
  UpperCAmelCase__							 =						96
 elif "base" in model_name:
  UpperCAmelCase__							 =						128
 elif "large" in model_name:
  UpperCAmelCase__							 =						192
 elif "xlarge" in model_name:
  UpperCAmelCase__							 =						256
 elif "huge" in model_name:
  UpperCAmelCase__							 =						352

 # set label information
 UpperCAmelCase__							 =						"huggingface/label-files"
 if "large" in model_name or "huge" in model_name:
  UpperCAmelCase__							 =						"imagenet-22k-id2label.json"
 else:
  UpperCAmelCase__							 =						"imagenet-1k-id2label.json"

 UpperCAmelCase__							 =						json.load(open(hf_hub_download(_lowerCAmelCase						,							_lowerCAmelCase						,							repo_type="dataset"	)						,							"r"	)	)
 UpperCAmelCase__							 =						{int(_lowerCAmelCase	): v for k, v in idalabel.items()}
 UpperCAmelCase__							 =						{v: k for k, v in idalabel.items()}

 UpperCAmelCase__							 =						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 						lowerCAmelCase		(		_lowerCAmelCase							:   Union[str, Any]	):




 """simple docstring"""







 if "patch_embed.proj" in name:
  UpperCAmelCase__							 =						name.replace("patch_embed.proj"						,							"embeddings.patch_embeddings.projection"	)
 if "patch_embed.norm" in name:
  UpperCAmelCase__							 =						name.replace("patch_embed.norm"						,							"embeddings.norm"	)
 if "layers" in name:
  UpperCAmelCase__							 =						"encoder." + name
 if "encoder.layers" in name:
  UpperCAmelCase__							 =						name.replace("encoder.layers"						,							"encoder.stages"	)
 if "downsample.proj" in name:
  UpperCAmelCase__							 =						name.replace("downsample.proj"						,							"downsample.projection"	)
 if "blocks" in name:
  UpperCAmelCase__							 =						name.replace("blocks"						,							"layers"	)
 if "modulation.f.weight" in name or "modulation.f.bias" in name:
  UpperCAmelCase__							 =						name.replace("modulation.f"						,							"modulation.projection_in"	)
 if "modulation.h.weight" in name or "modulation.h.bias" in name:
  UpperCAmelCase__							 =						name.replace("modulation.h"						,							"modulation.projection_context"	)
 if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
  UpperCAmelCase__							 =						name.replace("modulation.proj"						,							"modulation.projection_out"	)

 if name == "norm.weight":
  UpperCAmelCase__							 =						"layernorm.weight"
 if name == "norm.bias":
  UpperCAmelCase__							 =						"layernorm.bias"

 if "head" in name:
  UpperCAmelCase__							 =						name.replace("head"						,							"classifier"	)
 else:
  UpperCAmelCase__							 =						"focalnet." + name

 return name



def 						lowerCAmelCase		(		_lowerCAmelCase							:   int						,							_lowerCAmelCase							:   Any						,							_lowerCAmelCase							:   Union[str, Any]=False	):




 """simple docstring"""







 UpperCAmelCase__							 =						{
     "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

 UpperCAmelCase__							 =						model_name_to_url[model_name]
 print("Checkpoint URL: "						,							_lowerCAmelCase	)
 UpperCAmelCase__							 =						torch.hub.load_state_dict_from_url(_lowerCAmelCase						,							map_location="cpu"	)["model"]

 # rename keys
 for key in state_dict.copy().keys():
  UpperCAmelCase__							 =						state_dict.pop(_lowerCAmelCase	)
  UpperCAmelCase__							 =						val

 UpperCAmelCase__							 =						get_focalnet_config(_lowerCAmelCase	)
 UpperCAmelCase__							 =						FocalNetForImageClassification(_lowerCAmelCase	)
 model.eval()

 # load state dict
 model.load_state_dict(_lowerCAmelCase	)

 # verify conversion
 UpperCAmelCase__							 =						"http://images.cocodataset.org/val2017/000000039769.jpg"

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

 UpperCAmelCase__							 =						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]	),
     ]	)

 UpperCAmelCase__							 =						image_transforms(_lowerCAmelCase	).unsqueeze(0	)

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

 UpperCAmelCase__							 =						model(**_lowerCAmelCase	)

 UpperCAmelCase__							 =						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":
  UpperCAmelCase__							 =						torch.tensor([0.2_166, -0.4_368, 0.2_191]	)
 elif model_name == "focalnet-tiny-lrf":
  UpperCAmelCase__							 =						torch.tensor([1.1_669, 0.0_125, -0.1_695]	)
 elif model_name == "focalnet-small":
  UpperCAmelCase__							 =						torch.tensor([0.4_917, -0.0_430, 0.1_341]	)
 elif model_name == "focalnet-small-lrf":
  UpperCAmelCase__							 =						torch.tensor([-0.2_588, -0.5_342, -0.2_331]	)
 elif model_name == "focalnet-base":
  UpperCAmelCase__							 =						torch.tensor([-0.1_655, -0.4_090, -0.1_730]	)
 elif model_name == "focalnet-base-lrf":
  UpperCAmelCase__							 =						torch.tensor([0.5_306, -0.0_483, -0.3_928]	)
 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__":
  _lowerCAmelCase						:   Tuple		=   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						:   Optional[int]		=   parser.parse_args()
  convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











import math



def 						lowerCAmelCase		(		_lowerCAmelCase							:   int	):




 """simple docstring"""







 UpperCAmelCase__							 =						math.loga(math.sqrt(4 * positive_integer + 1	) / 2 + 1 / 2	)

 return exponent == int(_lowerCAmelCase	)



def 						lowerCAmelCase		(		_lowerCAmelCase							:   float = 1 / 1_2345	):




 """simple docstring"""







 UpperCAmelCase__							 =						0
 UpperCAmelCase__							 =						0

 UpperCAmelCase__							 =						3
 while True:
  UpperCAmelCase__							 =						(integer**2 - 1) / 4
  # if candidate is an integer, then there is a partition for k
  if partition_candidate == int(_lowerCAmelCase	):
   UpperCAmelCase__							 =						int(_lowerCAmelCase	)
   total_partitions += 1
   if check_partition_perfect(_lowerCAmelCase	):
    perfect_partitions += 1
  if perfect_partitions > 0:
   if perfect_partitions / total_partitions < max_proportion:
    return int(_lowerCAmelCase	)
  integer += 1


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





