


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





			'''simple docstring'''




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

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

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

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

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

			lowerCamelCase    		=  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__		:						Optional[int]      ):





			'''simple docstring'''




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

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

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

			return name






def 	__lowerCamelCase						(							lowerCamelCase__		:						Tuple  ,							lowerCamelCase__		:						List[Any]  ,							lowerCamelCase__		:						List[Any]=False      ):





			'''simple docstring'''




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

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

			# rename keys
			for key in state_dict.copy().keys():
						lowerCamelCase    		=  state_dict.pop(lowerCamelCase__      )
						lowerCamelCase    		=  val

			lowerCamelCase    		=  get_focalnet_config(lowerCamelCase__      )
			lowerCamelCase    		=  FocalNetForImageClassification(lowerCamelCase__      )
			model.eval()

			# load state dict
			model.load_state_dict(lowerCamelCase__      )

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

			lowerCamelCase    		=  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__  ,							)
			lowerCamelCase    		=  Image.open(requests.get(lowerCamelCase__  ,							stream=lowerCamelCase__      ).raw      )
			lowerCamelCase    		=  processor(images=lowerCamelCase__  ,							return_tensors="""pt"""      )

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

			lowerCamelCase    		=  image_transforms(lowerCamelCase__      ).unsqueeze(0      )

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

			lowerCamelCase    		=  model(**lowerCamelCase__      )

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

		UpperCAmelCase   :    Tuple     =		parser.parse_args()
		convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase   :    Union[str, Any]     =		logging.get_logger(__name__)

UpperCAmelCase   :    List[Any]     =		{
    "SCUT-DLVCLab/lilt-roberta-en-base": (
        "https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json"
    ),
}







class        __lowercase       (							a_  ):



		"""simple docstring"""

		UpperCamelCase     :					List[str]			       =		"lilt"







		def __init__( self		,      A=3_05_22		,      A=7_68		,      A=12		,      A=12		,      A=30_72		,      A="gelu"		,      A=0.1		,      A=0.1		,      A=5_12		,      A=2		,      A=0.02		,      A=1e-1_2		,      A=0		,      A="absolute"		,      A=None		,      A=4		,      A=10_24		,      **A		,      )  -> List[Any]:







					'''simple docstring'''







					super().__init__(pad_token_id=A		,      **A	)

					lowerCamelCase    		=  vocab_size
					lowerCamelCase    		=  hidden_size
					lowerCamelCase    		=  num_hidden_layers
					lowerCamelCase    		=  num_attention_heads
					lowerCamelCase    		=  hidden_act
					lowerCamelCase    		=  intermediate_size
					lowerCamelCase    		=  hidden_dropout_prob
					lowerCamelCase    		=  attention_probs_dropout_prob
					lowerCamelCase    		=  max_position_embeddings
					lowerCamelCase    		=  type_vocab_size
					lowerCamelCase    		=  initializer_range
					lowerCamelCase    		=  layer_norm_eps
					lowerCamelCase    		=  position_embedding_type
					lowerCamelCase    		=  classifier_dropout
					lowerCamelCase    		=  channel_shrink_ratio
					lowerCamelCase    		=  max_ad_position_embeddings

