





"""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_  :  Tuple						)       ->List[Any]:



    '''simple docstring'''







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

    if "tiny" in model_name or "small" in model_name or "base" in model_name:
        __A   :						List[Any]									=					[3, 3, 3, 3]
        if "lrf" in model_name:
            __A   :						List[Any]									=					[3, 3, 3, 3]
        else:
            __A   :						str									=					[2, 2, 2, 2]

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

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

    __A   :						Optional[Any]									=					json.load(open(hf_hub_download(snake_case_    ,snake_case_    ,repo_type='''dataset'''						)    ,'''r'''						)						)
    __A   :						Tuple									=					{int(snake_case_						): v for k, v in idalabel.items()}
    __A   :						str									=					{v: k for k, v in idalabel.items()}

    __A   :						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_  :  int						)       ->str:



    '''simple docstring'''







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

    if name == "norm.weight":
        __A   :						Union[str, Any]									=					'''layernorm.weight'''
    if name == "norm.bias":
        __A   :						str									=					'''layernorm.bias'''

    if "head" in name:
        __A   :						Dict									=					name.replace('''head'''    ,'''classifier'''						)
    else:
        __A   :						List[str]									=					'''focalnet.''' + name

    return name







def 		__lowercase					(       snake_case_  :  List[Any]    ,snake_case_  :  str    ,snake_case_  :  Tuple=False						)       ->str:



    '''simple docstring'''







    __A   :						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

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

    # rename keys
    for key in state_dict.copy().keys():
        __A   :						Union[str, Any]									=					state_dict.pop(snake_case_						)
        __A   :						Any									=					val

    __A   :						Any									=					get_focalnet_config(snake_case_						)
    __A   :						Dict									=					FocalNetForImageClassification(snake_case_						)
    model.eval()

    # load state dict
    model.load_state_dict(snake_case_						)

    # verify conversion
    __A   :						Optional[Any]									=					'''http://images.cocodataset.org/val2017/000000039769.jpg'''

    __A   :						Union[str, 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_    ,)
    __A   :						Optional[Any]									=					Image.open(requests.get(snake_case_    ,stream=snake_case_						).raw						)
    __A   :						Tuple									=					processor(images=snake_case_    ,return_tensors='''pt'''						)

    __A   :						List[str]									=					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]						),
        ]						)

    __A   :						Dict									=					image_transforms(snake_case_						).unsqueeze(0						)

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

    __A   :						List[Any]									=					model(**snake_case_						)

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

       a_			=      parser.parse_args()
       convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)











"""simple docstring"""



from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


a_			=      logging.get_logger(__name__)

a_			=      {
    """shi-labs/dinat-mini-in1k-224""": """https://huggingface.co/shi-labs/dinat-mini-in1k-224/resolve/main/config.json""",
    # See all Dinat models at https://huggingface.co/models?filter=dinat
}






class 		__snake_case (		SCREAMING_SNAKE_CASE__							,							SCREAMING_SNAKE_CASE__					):





 """simple docstring"""


 _lowerCamelCase				=					"""dinat"""

 _lowerCamelCase				=					{
     """num_attention_heads""": """num_heads""",
     """num_hidden_layers""": """num_layers""",
 }

 def __init__(   self ,						__lowerCamelCase=4 ,						__lowerCamelCase=3 ,						__lowerCamelCase=64 ,						__lowerCamelCase=[3, 4, 6, 5] ,						__lowerCamelCase=[2, 4, 8, 16] ,						__lowerCamelCase=7 ,						__lowerCamelCase=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]] ,						__lowerCamelCase=3.0 ,						__lowerCamelCase=True ,						__lowerCamelCase=0.0 ,						__lowerCamelCase=0.0 ,						__lowerCamelCase=0.1 ,						__lowerCamelCase="gelu" ,						__lowerCamelCase=0.0_2 ,						__lowerCamelCase=1e-5 ,						__lowerCamelCase=0.0 ,						__lowerCamelCase=None ,						__lowerCamelCase=None ,						**__lowerCamelCase ,						):



     '''simple docstring'''




     super().__init__(**__lowerCamelCase  )

     __A   :						Dict									=					patch_size
     __A   :						Union[str, Any]									=					num_channels
     __A   :						str									=					embed_dim
     __A   :						Optional[Any]									=					depths
     __A   :						int									=					len(__lowerCamelCase  )
     __A   :						Union[str, Any]									=					num_heads
     __A   :						Tuple									=					kernel_size
     __A   :						Optional[int]									=					dilations
     __A   :						Tuple									=					mlp_ratio
     __A   :						Optional[int]									=					qkv_bias
     __A   :						int									=					hidden_dropout_prob
     __A   :						Dict									=					attention_probs_dropout_prob
     __A   :						int									=					drop_path_rate
     __A   :						Dict									=					hidden_act
     __A   :						Any									=					layer_norm_eps
     __A   :						Tuple									=					initializer_range
     # we set the hidden_size attribute in order to make Dinat work with VisionEncoderDecoderModel
     # this indicates the channel dimension after the last stage of the model
     __A   :						str									=					int(embed_dim * 2 ** (len(__lowerCamelCase  ) - 1)  )
     __A   :						List[Any]									=					layer_scale_init_value
     __A   :						Any									=					['''stem'''] + [F"""stage{idx}""" for idx in range(1 ,						len(__lowerCamelCase  ) + 1  )]
     __A			,	__A   :						Union[str, Any]									=					get_aligned_output_features_output_indices(
         out_features=__lowerCamelCase ,						out_indices=__lowerCamelCase ,						stage_names=self.stage_names  )




