


'''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 _SCREAMING_SNAKE_CASE      (A       )       ->       int:






       """simple docstring"""







       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(A  , A  , repo_type='''dataset'''       )  , '''r'''       )       )
       lowercase__      			= {int(A       ): v for k, v in idalabel.items()}
       lowercase__      			= {v: k for k, v in idalabel.items()}

       lowercase__      			= 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 _SCREAMING_SNAKE_CASE      (A       )       ->       Dict:






       """simple docstring"""







       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      (A  , A  , A=False       )       ->       Any:






       """simple docstring"""







       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: '''  , A       )
       lowercase__      			= torch.hub.load_state_dict_from_url(A  , map_location='''cpu'''       )['''model''']

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

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

       # load state dict
       model.load_state_dict(A       )

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

       lowercase__      			= 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  , )
       lowercase__      			= Image.open(requests.get(A  , stream=A       ).raw       )
       lowercase__      			= processor(images=A  , 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(A       ).unsqueeze(0       )

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

       lowercase__      			= model(**A       )

       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.2_166, -0.4_368, 0.2_191]       )
       elif model_name == "focalnet-tiny-lrf":
              lowercase__      			= torch.tensor([1.1_669, 0.0_125, -0.1_695]       )
       elif model_name == "focalnet-small":
              lowercase__      			= torch.tensor([0.4_917, -0.0_430, 0.1_341]       )
       elif model_name == "focalnet-small-lrf":
              lowercase__      			= torch.tensor([-0.2_588, -0.5_342, -0.2_331]       )
       elif model_name == "focalnet-base":
              lowercase__      			= torch.tensor([-0.1_655, -0.4_090, -0.1_730]       )
       elif model_name == "focalnet-base-lrf":
              lowercase__      			= torch.tensor([0.5_306, -0.0_483, -0.3_928]       )
       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__":
 lowerCamelCase							:   str  						=	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.',
 )

 lowerCamelCase							:   Union[str, Any]  						=	parser.parse_args()
 convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











from dataclasses import dataclass
from typing import Optional, Tuple

import torch
from torch import nn
from transformers import RobertaPreTrainedModel, XLMRobertaConfig, XLMRobertaModel
from transformers.utils import ModelOutput







@dataclass
class     __snake_case       (							__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     None
       lowerCAmelCase__      		=     None
       lowerCAmelCase__      		=     None
       lowerCAmelCase__      		=     None







class     __snake_case       (							__lowerCamelCase			):





       '''simple docstring'''







       def __init__(  self :    Any							,				A :    List[str]=1							,				A :    str=0							,				A :    List[Any]=2							,				A :    Union[str, Any]=512							,				A :    Tuple="cls"							,				A :    Union[str, Any]=False							,				A :    Optional[Any]=True							,				**A :    Optional[int]							,				):
         super().__init__(pad_token_id=A							,				bos_token_id=A							,				eos_token_id=A							,				**A		)
         __snake_case:						str   =						project_dim
         __snake_case:						Optional[int]   =						pooler_fn
         __snake_case:						Dict   =						learn_encoder
         __snake_case:						str   =						use_attention_mask







class     __snake_case       (							__lowerCamelCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     [R"""pooler""", R"""logit_scale"""]
       lowerCAmelCase__      		=     [R"""position_ids""", R"""predictions.decoder.bias"""]
       lowerCAmelCase__      		=     """roberta"""
       lowerCAmelCase__      		=     RobertaSeriesConfig




       def __init__(  self :    Dict							,				A :    Dict		):
         super().__init__(A		)
         __snake_case:						Optional[Any]   =						XLMRobertaModel(A		)
         __snake_case:						List[Any]   =						nn.Linear(config.hidden_size							,				config.project_dim		)
         __snake_case:						Optional[int]   =						getattr(A							,				"""has_pre_transformation"""							,				A		)
         if self.has_pre_transformation:
           __snake_case:						Optional[Any]   =						nn.Linear(config.hidden_size							,				config.project_dim		)
           __snake_case:						Optional[Any]   =						nn.LayerNorm(config.hidden_size							,				eps=config.layer_norm_eps		)
         self.post_init()






       def 							UpperCAmelCase__ (  self :    Optional[Any]							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[torch.Tensor] = None							,				A :    Optional[bool] = None							,				A :    Optional[bool] = None							,				A :    Optional[bool] = None							,				):
         __snake_case:						Any   =						return_dict if return_dict is not None else self.config.use_return_dict

         __snake_case:						Optional[int]   =						self.base_model(
             input_ids=A							,				attention_mask=A							,				token_type_ids=A							,				position_ids=A							,				head_mask=A							,				inputs_embeds=A							,				encoder_hidden_states=A							,				encoder_attention_mask=A							,				output_attentions=A							,				output_hidden_states=True if self.has_pre_transformation else output_hidden_states							,				return_dict=A							,				)

         if self.has_pre_transformation:
           __snake_case:						int   =						outputs["""hidden_states"""][-2]
           __snake_case:						List[str]   =						self.pre_LN(A		)
           __snake_case:						List[str]   =						self.transformation_pre(A		)

           return TransformationModelOutput(
               projection_state=A							,				last_hidden_state=outputs.last_hidden_state							,				hidden_states=outputs.hidden_states							,				attentions=outputs.attentions							,				)
         else:
           __snake_case:						Optional[int]   =						self.transformation(outputs.last_hidden_state		)
           return TransformationModelOutput(
               projection_state=A							,				last_hidden_state=outputs.last_hidden_state							,				hidden_states=outputs.hidden_states							,				attentions=outputs.attentions							,				)






