
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       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     Tuple)   ->       Any:






							'''simple docstring'''





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

							if "tiny" in model_name or "small" in model_name or "base" in model_name:
														__UpperCamelCase      :  Optional[int]       =   [3, 3, 3, 3]
														if "lrf" in model_name:
																					__UpperCamelCase      :  str       =   [3, 3, 3, 3]
														else:
																					__UpperCamelCase      :  str       =   [2, 2, 2, 2]

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

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

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

							__UpperCamelCase      :  List[Any]       =   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       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     str)   ->       int:






							'''simple docstring'''





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

							if name == "norm.weight":
														__UpperCamelCase      :  Optional[Any]       =   "layernorm.weight"
							if name == "norm.bias":
														__UpperCamelCase      :  Optional[int]       =   "layernorm.bias"

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

							return name




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int		,    _lowerCamelCase					:     List[Any]		,    _lowerCamelCase					:     Optional[Any]=False)   ->       Any:






							'''simple docstring'''





							__UpperCamelCase      :  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

							__UpperCamelCase      :  Tuple       =   model_name_to_url[model_name]
							print("Checkpoint URL: "		,    _lowerCamelCase)
							__UpperCamelCase      :  int       =   torch.hub.load_state_dict_from_url(_lowerCamelCase		,    map_location="cpu")["model"]

							# rename keys
							for key in state_dict.copy().keys():
														__UpperCamelCase      :  Optional[Any]       =   state_dict.pop(_lowerCamelCase)
														__UpperCamelCase      :  Dict       =   val

							__UpperCamelCase      :  Dict       =   get_focalnet_config(_lowerCamelCase)
							__UpperCamelCase      :  Any       =   FocalNetForImageClassification(_lowerCamelCase)
							model.eval()

							# load state dict
							model.load_state_dict(_lowerCamelCase)

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

							__UpperCamelCase      :  int       =   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      :  List[Any]       =   Image.open(requests.get(_lowerCamelCase		,    stream=_lowerCamelCase).raw)
							__UpperCamelCase      :  Dict       =   processor(images=_lowerCamelCase		,    return_tensors="pt")

							__UpperCamelCase      :  Any       =   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]),
							    ])

							__UpperCamelCase      :  str       =   image_transforms(_lowerCamelCase).unsqueeze(0)

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

							__UpperCamelCase      :  Union[str, Any]       =   model(**_lowerCamelCase)

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

		lowercase    :   List[Any]						=			parser.parse_args()
		convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

import math




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       str:






							'''simple docstring'''





							__UpperCamelCase      :  Union[str, Any]       =   0
							__UpperCamelCase      :  int       =   0
							while num > 0:
														__UpperCamelCase      :  List[Any]       =   num % 8
														__UpperCamelCase      :  Tuple       =   octal + (remainder * math.floor(math.pow(10		,    _lowerCamelCase)))
														counter += 1
														__UpperCamelCase      :  Optional[Any]       =   math.floor(num / 8)  # basically /= 8 without remainder if any
														# This formatting removes trailing '.0' from `octal`.
							return F'0o{int(_lowerCamelCase)}'




def       _SCREAMING_SNAKE_CASE   (						)   ->       None:






							'''simple docstring'''





							print("\n2 in octal is:")
							print(decimal_to_octal(2))  # = 2
							print("\n8 in octal is:")
							print(decimal_to_octal(8))  # = 10
							print("\n65 in octal is:")
							print(decimal_to_octal(65))  # = 101
							print("\n216 in octal is:")
							print(decimal_to_octal(216))  # = 330
							print("\n512 in octal is:")
							print(decimal_to_octal(512))  # = 1000
							print("\n")


if __name__ == "__main__":
		main()