



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   :     str     ):



 """simple docstring"""





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

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

 if "tiny" in model_name:
  __SCREAMING_SNAKE_CASE       :    Dict       =	96
 elif "small" in model_name:
  __SCREAMING_SNAKE_CASE       :    Tuple       =	96
 elif "base" in model_name:
  __SCREAMING_SNAKE_CASE       :    Dict       =	128
 elif "large" in model_name:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	192
 elif "xlarge" in model_name:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	256
 elif "huge" in model_name:
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	352

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

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

 __SCREAMING_SNAKE_CASE       :    Dict       =	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   :     Tuple     ):



 """simple docstring"""





 if "patch_embed.proj" in name:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	name.replace("patch_embed.proj"		,	"embeddings.patch_embeddings.projection"     )
 if "patch_embed.norm" in name:
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	name.replace("patch_embed.norm"		,	"embeddings.norm"     )
 if "layers" in name:
  __SCREAMING_SNAKE_CASE       :    Dict       =	"encoder." + name
 if "encoder.layers" in name:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	name.replace("encoder.layers"		,	"encoder.stages"     )
 if "downsample.proj" in name:
  __SCREAMING_SNAKE_CASE       :    int       =	name.replace("downsample.proj"		,	"downsample.projection"     )
 if "blocks" in name:
  __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	name.replace("blocks"		,	"layers"     )
 if "modulation.f.weight" in name or "modulation.f.bias" in name:
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	name.replace("modulation.f"		,	"modulation.projection_in"     )
 if "modulation.h.weight" in name or "modulation.h.bias" in name:
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	name.replace("modulation.h"		,	"modulation.projection_context"     )
 if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
  __SCREAMING_SNAKE_CASE       :    Tuple       =	name.replace("modulation.proj"		,	"modulation.projection_out"     )

 if name == "norm.weight":
  __SCREAMING_SNAKE_CASE       :    Dict       =	"layernorm.weight"
 if name == "norm.bias":
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	"layernorm.bias"

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

 return name






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Optional[Any]		,	__lowerCamelCase   :     Optional[int]		,	__lowerCamelCase   :     Dict=False     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Dict       =	{
     "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

 __SCREAMING_SNAKE_CASE       :    str       =	model_name_to_url[model_name]
 print("Checkpoint URL: "		,	__lowerCamelCase     )
 __SCREAMING_SNAKE_CASE       :    List[str]       =	torch.hub.load_state_dict_from_url(__lowerCamelCase		,	map_location="cpu"     )["model"]

 # rename keys
 for key in state_dict.copy().keys():
  __SCREAMING_SNAKE_CASE       :    List[str]       =	state_dict.pop(__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	val

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	get_focalnet_config(__lowerCamelCase     )
 __SCREAMING_SNAKE_CASE       :    str       =	FocalNetForImageClassification(__lowerCamelCase     )
 model.eval()

 # load state dict
 model.load_state_dict(__lowerCamelCase     )

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

 __SCREAMING_SNAKE_CASE       :    Any       =	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		,	)
 __SCREAMING_SNAKE_CASE       :    Tuple       =	Image.open(requests.get(__lowerCamelCase		,	stream=__lowerCamelCase     ).raw     )
 __SCREAMING_SNAKE_CASE       :    str       =	processor(images=__lowerCamelCase		,	return_tensors="pt"     )

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	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]     ),
     ]     )

 __SCREAMING_SNAKE_CASE       :    List[str]       =	image_transforms(__lowerCamelCase     ).unsqueeze(0     )

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

 __SCREAMING_SNAKE_CASE       :    str       =	model(**__lowerCamelCase     )

 __SCREAMING_SNAKE_CASE       :    Optional[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":
  __SCREAMING_SNAKE_CASE       :    List[str]       =	torch.tensor([0.2166, -0.4368, 0.2191]     )
 elif model_name == "focalnet-tiny-lrf":
  __SCREAMING_SNAKE_CASE       :    Any       =	torch.tensor([1.1669, 0.0125, -0.1695]     )
 elif model_name == "focalnet-small":
  __SCREAMING_SNAKE_CASE       :    Tuple       =	torch.tensor([0.4917, -0.0430, 0.1341]     )
 elif model_name == "focalnet-small-lrf":
  __SCREAMING_SNAKE_CASE       :    Tuple       =	torch.tensor([-0.2588, -0.5342, -0.2331]     )
 elif model_name == "focalnet-base":
  __SCREAMING_SNAKE_CASE       :    int       =	torch.tensor([-0.1655, -0.4090, -0.1730]     )
 elif model_name == "focalnet-base-lrf":
  __SCREAMING_SNAKE_CASE       :    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__":
      _lowerCamelCase						    =  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						    =  parser.parse_args()
      convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











from collections.abc import Generator
from math import sin






def 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 if len(__lowerCamelCase     ) != 32:
  raise ValueError("Input must be of length 32"     )

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	b""
 for i in [3, 2, 1, 0]:
  little_endian += string_aa[8 * i : 8 * i + 8]
 return little_endian






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int     ):



 """simple docstring"""





 if i < 0:
  raise ValueError("Input must be non-negative"     )

 __SCREAMING_SNAKE_CASE       :    Any       =	format(__lowerCamelCase		,	"08x"     )[-8:]
 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	b""
 for i in [3, 2, 1, 0]:
  little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode("utf-8"     )
 return little_endian_hex






def 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Any       =	b""
 for char in message:
  bit_string += format(__lowerCamelCase		,	"08b"     ).encode("utf-8"     )
 __SCREAMING_SNAKE_CASE       :    List[str]       =	format(len(__lowerCamelCase     )		,	"064b"     ).encode("utf-8"     )

 # Pad bit_string to a multiple of 512 chars
 bit_string += b"1"
 while len(__lowerCamelCase     ) % 512 != 448:
  bit_string += b"0"
 bit_string += to_little_endian(start_len[32:]     ) + to_little_endian(start_len[:32]     )

 return bit_string






def 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 if len(__lowerCamelCase     ) % 512 != 0:
  raise ValueError("Input must have length that's a multiple of 512"     )

 for pos in range(0		,	len(__lowerCamelCase     )		,	512     ):
  __SCREAMING_SNAKE_CASE       :    int       =	bit_string[pos : pos + 512]
  __SCREAMING_SNAKE_CASE       :    Tuple       =	[]
  for i in range(0		,	512		,	32     ):
   block_words.append(int(to_little_endian(block[i : i + 32]     )		,	2     )     )
  yield block_words






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int     ):



 """simple docstring"""





 if i < 0:
  raise ValueError("Input must be non-negative"     )

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	format(__lowerCamelCase		,	"032b"     )
 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	""
 for c in i_str:
  new_str += "1" if c == "0" else "0"
 return int(__lowerCamelCase		,	2     )






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int		,	__lowerCamelCase   :     int     ):



 """simple docstring"""





 return (a + b) % 2**32






def 	_lowerCAmelCase						(				__lowerCamelCase   :     int		,	__lowerCamelCase   :     int     ):



 """simple docstring"""





 if i < 0:
  raise ValueError("Input must be non-negative"     )
 if shift < 0:
  raise ValueError("Shift must be non-negative"     )
 return ((i << shift) ^ (i >> (32 - shift))) % 2**32






def 	_lowerCAmelCase						(				__lowerCamelCase   :     bytes     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Tuple       =	preprocess(__lowerCamelCase     )

 __SCREAMING_SNAKE_CASE       :    List[Any]       =	[int(2**32 * abs(sin(i + 1     )     )     ) for i in range(64     )]

 # Starting states
 __SCREAMING_SNAKE_CASE       :    Tuple       =	0X67452301
 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	0Xefcdab89
 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	0X98badcfe
 __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	0X10325476

 __SCREAMING_SNAKE_CASE       :    List[Any]       =	[
     7,
     12,
     17,
     22,
     7,
     12,
     17,
     22,
     7,
     12,
     17,
     22,
     7,
     12,
     17,
     22,
     5,
     9,
     14,
     20,
     5,
     9,
     14,
     20,
     5,
     9,
     14,
     20,
     5,
     9,
     14,
     20,
     4,
     11,
     16,
     23,
     4,
     11,
     16,
     23,
     4,
     11,
     16,
     23,
     4,
     11,
     16,
     23,
     6,
     10,
     15,
     21,
     6,
     10,
     15,
     21,
     6,
     10,
     15,
     21,
     6,
     10,
     15,
     21,
 ]

 # Process bit string in chunks, each with 16 32-char words
 for block_words in get_block_words(__lowerCamelCase     ):
  __SCREAMING_SNAKE_CASE       :    Any       =	aa
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	ba
  __SCREAMING_SNAKE_CASE       :    str       =	ca
  __SCREAMING_SNAKE_CASE       :    Dict       =	da

  # Hash current chunk
  for i in range(64     ):
   if i <= 15:
    # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
    __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	d ^ (b & (c ^ d))
    __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	i
   elif i <= 31:
    # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
    __SCREAMING_SNAKE_CASE       :    int       =	c ^ (d & (b ^ c))
    __SCREAMING_SNAKE_CASE       :    int       =	(5 * i + 1) % 16
   elif i <= 47:
    __SCREAMING_SNAKE_CASE       :    List[str]       =	b ^ c ^ d
    __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	(3 * i + 5) % 16
   else:
    __SCREAMING_SNAKE_CASE       :    Any       =	c ^ (b | not_aa(__lowerCamelCase     ))
    __SCREAMING_SNAKE_CASE       :    str       =	(7 * i) % 16
   __SCREAMING_SNAKE_CASE       :    List[str]       =	(f + a + added_consts[i] + block_words[g]) % 2**32
   __SCREAMING_SNAKE_CASE       :    Dict       =	d
   __SCREAMING_SNAKE_CASE       :    str       =	c
   __SCREAMING_SNAKE_CASE       :    Tuple       =	b
   __SCREAMING_SNAKE_CASE       :    Optional[int]       =	sum_aa(__lowerCamelCase		,	left_rotate_aa(__lowerCamelCase		,	shift_amounts[i]     )     )

  # Add hashed chunk to running total
  __SCREAMING_SNAKE_CASE       :    Dict       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )
  __SCREAMING_SNAKE_CASE       :    str       =	sum_aa(__lowerCamelCase		,	__lowerCamelCase     )

 __SCREAMING_SNAKE_CASE       :    List[str]       =	reformat_hex(__lowerCamelCase     ) + reformat_hex(__lowerCamelCase     ) + reformat_hex(__lowerCamelCase     ) + reformat_hex(__lowerCamelCase     )
 return digest


if __name__ == "__main__":
      import doctest

      doctest.testmod()






