






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







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

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

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

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

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

				snake_case__													=   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    a_       (					_A     )	->	List[Any]:







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

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

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

				return name
def    a_       (					_A					,      _A					,      _A=False     )	->	Dict:







				"""simple docstring"""
				# fmt: off
				snake_case__													=   {
				    "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__													=   model_name_to_url[model_name]
				print('Checkpoint URL: '					,      __snake_case     )
				snake_case__													=   torch.hub.load_state_dict_from_url(__snake_case					,      map_location='cpu'     )["model"]

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

				snake_case__													=   get_focalnet_config(__snake_case     )
				snake_case__													=   FocalNetForImageClassification(__snake_case     )
				model.eval()

				# load state dict
				model.load_state_dict(__snake_case     )

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

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

				snake_case__													=   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__													=   image_transforms(__snake_case     ).unsqueeze(0     )

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

				snake_case__													=   model(**__snake_case     )

				snake_case__													=   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__													=   torch.tensor([0.2166, -0.4368, 0.2191]     )
				elif model_name == "focalnet-tiny-lrf":
								snake_case__													=   torch.tensor([1.1669, 0.0125, -0.1695]     )
				elif model_name == "focalnet-small":
								snake_case__													=   torch.tensor([0.4917, -0.0430, 0.1341]     )
				elif model_name == "focalnet-small-lrf":
								snake_case__													=   torch.tensor([-0.2588, -0.5342, -0.2331]     )
				elif model_name == "focalnet-base":
								snake_case__													=   torch.tensor([-0.1655, -0.4090, -0.1730]     )
				elif model_name == "focalnet-base-lrf":
								snake_case__													=   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__":
							__UpperCamelCase    :						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    :						Optional[int]		     =  parser.parse_args()
							convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






"""simple docstring"""




import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()


def   __magic_name__	(      __snake_case				:       Optional[Any]     , __snake_case				:       Dict     , __snake_case				:       Any  ) ->				Any:
       # Initialise PyTorch model
       lowercase    :				Union[str, Any]       		=							RemBertConfig.from_json_file(__snake_case  )
       print("Building PyTorch model from configuration: {}".format(str(__snake_case  )  )  )
       lowercase    :				str       		=							RemBertModel(__snake_case  )

       # Load weights from tf checkpoint
       load_tf_weights_in_rembert(__snake_case     , __snake_case     , __snake_case  )

       # Save pytorch-model
       print("Save PyTorch model to {}".format(__snake_case  )  )
       torch.save(model.state_dict()     , __snake_case  )


if __name__ == "__main__":
   _A			:       str   		=       argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
   )
   parser.add_argument(
       """--rembert_config_file""",
       default=None,
       type=str,
       required=True,
       help=(
           """The config json file corresponding to the pre-trained RemBERT model. \n"""
           """This specifies the model architecture."""
       ),
   )
   parser.add_argument(
       """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
   )
   _A			:       List[str]   		=       parser.parse_args()
   convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)


