






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    UpperCamelCase						(	_A			):






						"""simple docstring"""







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

						if "tiny" in model_name or "small" in model_name or "base" in model_name:
												__magic_name__      :       Dict       						= [3, 3, 3, 3]
												if "lrf" in model_name:
																		__magic_name__      :       Tuple       						= [3, 3, 3, 3]
												else:
																		__magic_name__      :       str       						= [2, 2, 2, 2]

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

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

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

						__magic_name__      :       str       						= FocalNetConfig(
						    embed_dim=_A,   depths=_A,   focal_levels=_A,   focal_windows=_A,   use_conv_embed=_A,   idalabel=_A,   labelaid=_A,   use_post_layernorm=_A,   use_layerscale=_A,   )

						return config

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







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

						if name == "norm.weight":
												__magic_name__      :       int       						= """layernorm.weight"""
						if name == "norm.bias":
												__magic_name__      :       str       						= """layernorm.bias"""

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

						return name

def    UpperCamelCase						(	_A,   _A,   _A=False			):






						"""simple docstring"""







						__magic_name__      :       List[str]       						= {
						    """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

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

						# rename keys
						for key in state_dict.copy().keys():
												__magic_name__      :       List[Any]       						= state_dict.pop(_A			)
												__magic_name__      :       List[Any]       						= val

						__magic_name__      :       str       						= get_focalnet_config(_A			)
						__magic_name__      :       Any       						= FocalNetForImageClassification(_A			)
						model.eval()

						# load state dict
						model.load_state_dict(_A			)

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

						__magic_name__      :       Optional[int]       						= BitImageProcessor(
						    do_resize=_A,   size={"""shortest_edge""": 256},   resample=PILImageResampling.BILINEAR,   do_center_crop=_A,   crop_size=224,   do_normalize=_A,   image_mean=_A,   image_std=_A,   )
						__magic_name__      :       Dict       						= Image.open(requests.get(_A,   stream=_A			).raw			)
						__magic_name__      :       Optional[int]       						= processor(images=_A,   return_tensors="""pt"""			)

						__magic_name__      :       List[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]			),
						    ]			)

						__magic_name__      :       int       						= image_transforms(_A			).unsqueeze(0			)

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

						__magic_name__      :       Dict       						= model(**_A			)

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

						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__":
		__magic_name__:					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.",
		)

		__magic_name__:					Dict							=     parser.parse_args()
		convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import unittest

from transformers import is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow


if is_flax_available():
		import optax
		from flax.training.common_utils import onehot

		from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration
		from transformers.models.ta.modeling_flax_ta import shift_tokens_right





@require_torch
@require_sentencepiece
@require_tokenizers
@require_flax
class 	snake_case__ (							unittest.TestCase				):
	@slow
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Any       						= FlaxMTaForConditionalGeneration.from_pretrained("""google/mt5-small"""			)
							__magic_name__      :       Dict       						= AutoTokenizer.from_pretrained("""google/mt5-small"""			)

							__magic_name__      :       Tuple       						= tokenizer("""Hello there"""      ,       return_tensors="""np"""			).input_ids
							__magic_name__      :       List[Any]       						= tokenizer("""Hi I am"""      ,       return_tensors="""np"""			).input_ids

							__magic_name__      :       Any       						= shift_tokens_right(lowerCAmelCase__      ,       model.config.pad_token_id      ,       model.config.decoder_start_token_id			)

							__magic_name__      :       List[Any]       						= model(lowerCAmelCase__      ,       decoder_input_ids=lowerCAmelCase__			).logits
							__magic_name__      :       Tuple       						= optax.softmax_cross_entropy(lowerCAmelCase__      ,       onehot(lowerCAmelCase__      ,       logits.shape[-1]			)			).mean()

							__magic_name__      :       List[Any]       						= -(labels.shape[-1] * loss.item())

							__magic_name__      :       List[Any]       						= -8_4.9_1_2_7
							self.assertTrue(abs(mtf_score - EXPECTED_SCORE			) < 1e-4			)
