


"""simple docstring"""
import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
			from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
			from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
			from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


SCREAMING_SNAKE_CASE :    Union[str, Any]									=				DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

SCREAMING_SNAKE_CASE :    str									=				"""main"""
# Default branch name
SCREAMING_SNAKE_CASE :    str									=				"""f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"""
# One particular commit (not the top of `main`)
SCREAMING_SNAKE_CASE :    Union[str, Any]									=				"""aaaaaaa"""
# This commit does not exist, so we should 404.

SCREAMING_SNAKE_CASE :    str									=				"""d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"""
# Sha-1 of config.json on the top of `main`, for checking purposes
SCREAMING_SNAKE_CASE :    str									=				"""4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"""






@contextlib.contextmanager
def 		lowercase							(     )     ->List[Any]:
	"""simple docstring"""





	print('''Welcome!'''     )
	yield
	print('''Bye!'''     )






@contextlib.contextmanager
def 		lowercase							(     )     ->Dict:
	"""simple docstring"""





	print('''Bonjour!'''     )
	yield
	print('''Au revoir!'''     )



class 			_UpperCAmelCase (							unittest.TestCase				):






		'''simple docstring'''

		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			assert transformers.__spec__ is not None
			assert importlib.util.find_spec('''transformers'''					) is not None



class 			_UpperCAmelCase (							unittest.TestCase				):






		'''simple docstring'''

		@unittest.mock.patch('''sys.stdout'''				,       new_callable=io.StringIO					)
		def 				SCREAMING_SNAKE_CASE  (self				,       a_					):





			'''simple docstring'''

			with ContextManagers([]					):
				print('''Transformers are awesome!'''					)
			# The print statement adds a new line at the end of the output
			self.assertEqual(mock_stdout.getvalue()				,       '''Transformers are awesome!\n'''					)



		@unittest.mock.patch('''sys.stdout'''				,       new_callable=io.StringIO					)
		def 				SCREAMING_SNAKE_CASE  (self				,       a_					):





			'''simple docstring'''

			with ContextManagers([context_en()]					):
				print('''Transformers are awesome!'''					)
			# The output should be wrapped with an English welcome and goodbye
			self.assertEqual(mock_stdout.getvalue()				,       '''Welcome!\nTransformers are awesome!\nBye!\n'''					)



		@unittest.mock.patch('''sys.stdout'''				,       new_callable=io.StringIO					)
		def 				SCREAMING_SNAKE_CASE  (self				,       a_					):





			'''simple docstring'''

			with ContextManagers([context_fr(), context_en()]					):
				print('''Transformers are awesome!'''					)
			# The output should be wrapped with an English and French welcome and goodbye
			self.assertEqual(mock_stdout.getvalue()				,       '''Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n'''					)



		@require_torch
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self.assertEqual(find_labels(a_					)				,       ['''labels''']					)
			self.assertEqual(find_labels(a_					)				,       ['''labels''', '''next_sentence_label''']					)
			self.assertEqual(find_labels(a_					)				,       ['''start_positions''', '''end_positions''']					)



			class 			_UpperCAmelCase (							__snake_case				):






					'''simple docstring'''

					pass

			self.assertEqual(find_labels(a_					)				,       ['''labels''']					)



		@require_tf
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self.assertEqual(find_labels(a_					)				,       ['''labels''']					)
			self.assertEqual(find_labels(a_					)				,       ['''labels''', '''next_sentence_label''']					)
			self.assertEqual(find_labels(a_					)				,       ['''start_positions''', '''end_positions''']					)



			class 			_UpperCAmelCase (							__snake_case				):






					'''simple docstring'''

					pass

			self.assertEqual(find_labels(a_					)				,       ['''labels''']					)



		@require_flax
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self.assertEqual(find_labels(a_					)				,       []					)
			self.assertEqual(find_labels(a_					)				,       []					)
			self.assertEqual(find_labels(a_					)				,       []					)



			class 			_UpperCAmelCase (							__snake_case				):






					'''simple docstring'''

					pass

			self.assertEqual(find_labels(a_					)				,       []					)









"""simple docstring"""
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 		lowercase							(     _snake_case						:      Any     )     ->Union[str, Any]:
	"""simple docstring"""





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

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

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

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

	__snake_case	:						int						=				json.load(open(hf_hub_download(_snake_case     ,   _snake_case     ,   repo_type='''dataset'''     )     ,   '''r'''     )     )
	__snake_case	:						Dict						=				{int(_snake_case     ): v for k, v in idalabel.items()}
	__snake_case	:						Optional[int]						=				{v: k for k, v in idalabel.items()}

	__snake_case	:						Optional[Any]						=				FocalNetConfig(
	    embed_dim=_snake_case     ,   depths=_snake_case     ,   focal_levels=_snake_case     ,   focal_windows=_snake_case     ,   use_conv_embed=_snake_case     ,   idalabel=_snake_case     ,   labelaid=_snake_case     ,   use_post_layernorm=_snake_case     ,   use_layerscale=_snake_case     ,   )

	return config






def 		lowercase							(     _snake_case						:      Dict     )     ->List[Any]:
	"""simple docstring"""





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

	if name == "norm.weight":
		__snake_case	:						Optional[Any]						=				'''layernorm.weight'''
	if name == "norm.bias":
		__snake_case	:						List[str]						=				'''layernorm.bias'''

	if "head" in name:
		__snake_case	:						Union[str, Any]						=				name.replace('''head'''     ,   '''classifier'''     )
	else:
		__snake_case	:						int						=				'''focalnet.''' + name

	return name






def 		lowercase							(     _snake_case						:      Tuple     ,   _snake_case						:      Dict     ,   _snake_case						:      List[str]=False     )     ->Any:
	"""simple docstring"""





	__snake_case	:						List[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

	__snake_case	:						int						=				model_name_to_url[model_name]
	print('''Checkpoint URL: '''     ,   _snake_case     )
	__snake_case	:						int						=				torch.hub.load_state_dict_from_url(_snake_case     ,   map_location='''cpu'''     )['''model''']

	# rename keys
	for key in state_dict.copy().keys():
		__snake_case	:						str						=				state_dict.pop(_snake_case     )
		__snake_case	:						Tuple						=				val

	__snake_case	:						Any						=				get_focalnet_config(_snake_case     )
	__snake_case	:						List[Any]						=				FocalNetForImageClassification(_snake_case     )
	model.eval()

	# load state dict
	model.load_state_dict(_snake_case     )

	# verify conversion
	__snake_case	:						str						=				'''http://images.cocodataset.org/val2017/000000039769.jpg'''

	__snake_case	:						Any						=				BitImageProcessor(
	    do_resize=_snake_case     ,   size={'''shortest_edge''': 256}     ,   resample=PILImageResampling.BILINEAR     ,   do_center_crop=_snake_case     ,   crop_size=224     ,   do_normalize=_snake_case     ,   image_mean=_snake_case     ,   image_std=_snake_case     ,   )
	__snake_case	:						List[str]						=				Image.open(requests.get(_snake_case     ,   stream=_snake_case     ).raw     )
	__snake_case	:						int						=				processor(images=_snake_case     ,   return_tensors='''pt'''     )

	__snake_case	:						Optional[int]						=				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]     ),
	    ]     )

	__snake_case	:						Optional[Any]						=				image_transforms(_snake_case     ).unsqueeze(0     )

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

	__snake_case	:						Tuple						=				model(**_snake_case     )

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

			SCREAMING_SNAKE_CASE :    str									=				parser.parse_args()
			convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





