



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

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

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

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

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

			lowercase__					  =				FocalNetConfig(
			    embed_dim=SCREAMING_SNAKE_CASE_						,  depths=SCREAMING_SNAKE_CASE_						,  focal_levels=SCREAMING_SNAKE_CASE_						,  focal_windows=SCREAMING_SNAKE_CASE_						,  use_conv_embed=SCREAMING_SNAKE_CASE_						,  idalabel=SCREAMING_SNAKE_CASE_						,  labelaid=SCREAMING_SNAKE_CASE_						,  use_post_layernorm=SCREAMING_SNAKE_CASE_						,  use_layerscale=SCREAMING_SNAKE_CASE_						,  )

			return config



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

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

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

			return name



def __SCREAMING_SNAKE_CASE (     SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_=False  ):
			# fmt: off
			lowercase__					  =				{
			    "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

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

			# rename keys
			for key in state_dict.copy().keys():
						lowercase__					  =				state_dict.pop(SCREAMING_SNAKE_CASE_  )
						lowercase__					  =				val

			lowercase__					  =				get_focalnet_config(SCREAMING_SNAKE_CASE_  )
			lowercase__					  =				FocalNetForImageClassification(SCREAMING_SNAKE_CASE_  )
			model.eval()

			# load state dict
			model.load_state_dict(SCREAMING_SNAKE_CASE_  )

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

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

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

			lowercase__					  =				image_transforms(SCREAMING_SNAKE_CASE_  ).unsqueeze(0  )

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

			lowercase__					  =				model(**SCREAMING_SNAKE_CASE_  )

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

			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_								=     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_								=     parser.parse_args()
							convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









import os
import unittest

from transformers.models.transfo_xl.tokenization_transfo_xl import VOCAB_FILES_NAMES, TransfoXLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Dict     		=TransfoXLTokenizer
				UpperCamelCase__				:					List[Any]     		=False
				UpperCamelCase__				:					List[Any]     		=False




				def 							A__      (						self					:						Union[str, Any]						):
							super().setUp()

							lowercase__					  =				[
							    "<unk>",
							    "[CLS]",
							    "[SEP]",
							    "want",
							    "unwanted",
							    "wa",
							    "un",
							    "running",
							    ",",
							    "low",
							    "l",
							]
							lowercase__					  =				os.path.join(self.tmpdirname,					VOCAB_FILES_NAMES["vocab_file"]						)
							with open(self.vocab_file,					"w",					encoding="utf-8"						) as vocab_writer:
										vocab_writer.write("".join([x + "\n" for x in vocab_tokens]						)						)




				def 							A__      (						self					:						Union[str, Any],					**__lowercase					:						Any						):
							lowercase__					  =				True
							return TransfoXLTokenizer.from_pretrained(self.tmpdirname,					**__lowercase						)




				def 							A__      (						self					:						Tuple,					__lowercase					:						Optional[int]						):
							lowercase__					  =				"<unk> UNwanted , running"
							lowercase__					  =				"<unk> unwanted, running"
							return input_text, output_text




				def 							A__      (						self					:						str						):
							lowercase__					  =				TransfoXLTokenizer(vocab_file=self.vocab_file,					lower_case=__lowercase						)

							lowercase__					  =				tokenizer.tokenize("<unk> UNwanted , running"						)
							self.assertListEqual(__lowercase,					["<unk>", "unwanted", ",", "running"]						)

							self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowercase						),					[0, 4, 8, 7]						)




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				TransfoXLTokenizer(lower_case=__lowercase						)

							self.assertListEqual(
							    tokenizer.tokenize(" \tHeLLo ! how  \n Are yoU ?  "						),					["hello", "!", "how", "are", "you", "?"]						)




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				TransfoXLTokenizer(lower_case=__lowercase						)

							self.assertListEqual(
							    tokenizer.tokenize(" \tHeLLo ! how  \n Are yoU ?  "						),					["HeLLo", "!", "how", "Are", "yoU", "?"]						)




				def 							A__      (						self					:						str						):
							lowercase__					  =				TransfoXLTokenizer(lower_case=__lowercase						)
							lowercase__					  =				"Hello (bracket) and side-scrolled [and] Henry's $5,000 with 3.34 m. What's up!?"
							lowercase__					  =				[
							    "Hello",
							    "(",
							    "bracket",
							    ")",
							    "and",
							    "side",
							    "@-@",
							    "scrolled",
							    "[",
							    "and",
							    "]",
							    "Henry",
							    "'s",
							    "$",
							    "5",
							    "@,@",
							    "000",
							    "with",
							    "3",
							    "@.@",
							    "34",
							    "m",
							    ".",
							    "What",
							    "'s",
							    "up",
							    "!",
							    "?",
							]

							self.assertListEqual(tokenizer.tokenize(__lowercase						),					__lowercase						)

							self.assertEqual(tokenizer.convert_tokens_to_string(__lowercase						),					__lowercase						)




				def 							A__      (						self					:						List[str]						):
							lowercase__					  =				self.get_tokenizer()
							lowercase__					  =				len(__lowercase						)

							tokenizer.add_tokens(["new1", "new2"]						)
							tokenizer.move_added_token("new1",					1						)

							# Check that moved token is not copied (duplicate)
							self.assertEqual(len(__lowercase						),					original_len + 2						)
							# Check that token is moved to specified id
							self.assertEqual(tokenizer.encode("new1"						),					[1]						)
							self.assertEqual(tokenizer.decode([1]						),					"new1"						)




