





"""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_    :    Union[str, Any]		)  ->Any:



    '''simple docstring'''







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

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

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

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

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

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



    '''simple docstring'''







    if "patch_embed.proj" in name:
        __A       :		str							=	name.replace('''patch_embed.proj'''							,'''embeddings.patch_embeddings.projection'''		)
    if "patch_embed.norm" in name:
        __A       :		Union[str, Any]							=	name.replace('''patch_embed.norm'''							,'''embeddings.norm'''		)
    if "layers" in name:
        __A       :		Dict							=	'''encoder.''' + name
    if "encoder.layers" in name:
        __A       :		List[Any]							=	name.replace('''encoder.layers'''							,'''encoder.stages'''		)
    if "downsample.proj" in name:
        __A       :		str							=	name.replace('''downsample.proj'''							,'''downsample.projection'''		)
    if "blocks" in name:
        __A       :		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       :		List[Any]							=	name.replace('''modulation.proj'''							,'''modulation.projection_out'''		)

    if name == "norm.weight":
        __A       :		str							=	'''layernorm.weight'''
    if name == "norm.bias":
        __A       :		str							=	'''layernorm.bias'''

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

    return name







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



    '''simple docstring'''







    __A       :		int							=	{
        '''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       :		Optional[int]							=	torch.hub.load_state_dict_from_url(snake_case_							,map_location='''cpu'''		)['''model''']

    # rename keys
    for key in state_dict.copy().keys():
        __A       :		Optional[int]							=	state_dict.pop(snake_case_		)
        __A       :		Optional[int]							=	val

    __A       :		Union[str, Any]							=	get_focalnet_config(snake_case_		)
    __A       :		str							=	FocalNetForImageClassification(snake_case_		)
    model.eval()

    # load state dict
    model.load_state_dict(snake_case_		)

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

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

    __A       :		Optional[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]		),
        ]		)

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

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

    __A       :		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       :		Any							=	torch.tensor([0.2_166, -0.4_368, 0.2_191]		)
    elif model_name == "focalnet-tiny-lrf":
        __A       :		str							=	torch.tensor([1.1_669, 0.0_125, -0.1_695]		)
    elif model_name == "focalnet-small":
        __A       :		Optional[int]							=	torch.tensor([0.4_917, -0.0_430, 0.1_341]		)
    elif model_name == "focalnet-small-lrf":
        __A       :		Any							=	torch.tensor([-0.2_588, -0.5_342, -0.2_331]		)
    elif model_name == "focalnet-base":
        __A       :		str							=	torch.tensor([-0.1_655, -0.4_090, -0.1_730]		)
    elif model_name == "focalnet-base-lrf":
        __A       :		Optional[Any]							=	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 collections import namedtuple

a_					=     namedtuple("""from_to""", """from_ to""")

a_					=     {
    """cubicmeter""": from_to(1, 1),
    """litre""": from_to(0.001, 1000),
    """kilolitre""": from_to(1, 1),
    """gallon""": from_to(0.00454, 264.172),
    """cubicyard""": from_to(0.76455, 1.30795),
    """cubicfoot""": from_to(0.028, 35.3147),
    """cup""": from_to(0.000236588, 4226.75),
}







def 						__lowercase	(  snake_case_    :    float							,snake_case_    :    str							,snake_case_    :    str		)  ->float:



    '''simple docstring'''







    if from_type not in METRIC_CONVERSION:
        raise ValueError(
            F"""Invalid 'from_type' value: {from_type!r}  Supported values are:\n"""
            + ''', '''.join(snake_case_		)		)
    if to_type not in METRIC_CONVERSION:
        raise ValueError(
            F"""Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"""
            + ''', '''.join(snake_case_		)		)
    return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to


if __name__ == "__main__":
       import doctest

       doctest.testmod()




