



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

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

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

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

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

    snake_case_ :     Optional[Any]				=	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 __lowercase			(							_a    ):
    if "patch_embed.proj" in name:
        snake_case_ :     Dict				=	name.replace('''patch_embed.proj'''		,			'''embeddings.patch_embeddings.projection'''    )
    if "patch_embed.norm" in name:
        snake_case_ :     Any				=	name.replace('''patch_embed.norm'''		,			'''embeddings.norm'''    )
    if "layers" in name:
        snake_case_ :     str				=	'''encoder.''' + name
    if "encoder.layers" in name:
        snake_case_ :     List[Any]				=	name.replace('''encoder.layers'''		,			'''encoder.stages'''    )
    if "downsample.proj" in name:
        snake_case_ :     List[str]				=	name.replace('''downsample.proj'''		,			'''downsample.projection'''    )
    if "blocks" in name:
        snake_case_ :     Union[str, Any]				=	name.replace('''blocks'''		,			'''layers'''    )
    if "modulation.f.weight" in name or "modulation.f.bias" in name:
        snake_case_ :     List[Any]				=	name.replace('''modulation.f'''		,			'''modulation.projection_in'''    )
    if "modulation.h.weight" in name or "modulation.h.bias" in name:
        snake_case_ :     Dict				=	name.replace('''modulation.h'''		,			'''modulation.projection_context'''    )
    if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
        snake_case_ :     List[Any]				=	name.replace('''modulation.proj'''		,			'''modulation.projection_out'''    )

    if name == "norm.weight":
        snake_case_ :     Optional[int]				=	'''layernorm.weight'''
    if name == "norm.bias":
        snake_case_ :     int				=	'''layernorm.bias'''

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

    return name




def __lowercase			(							_a		,			_a		,			_a=False    ):
    # fmt: off
    snake_case_ :     Optional[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

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

    # rename keys
    for key in state_dict.copy().keys():
        snake_case_ :     Tuple				=	state_dict.pop(_a    )
        snake_case_ :     int				=	val

    snake_case_ :     int				=	get_focalnet_config(_a    )
    snake_case_ :     str				=	FocalNetForImageClassification(_a    )
    model.eval()

    # load state dict
    model.load_state_dict(_a    )

    # verify conversion
    snake_case_ :     Union[str, Any]				=	'''http://images.cocodataset.org/val2017/000000039769.jpg'''

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

    snake_case_ :     int				=	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_ :     List[Any]				=	image_transforms(_a    ).unsqueeze(0    )

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

    snake_case_ :     Optional[Any]				=	model(**_a    )

    snake_case_ :     List[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":
        snake_case_ :     Dict				=	torch.tensor([0.2166, -0.4368, 0.2191]    )
    elif model_name == "focalnet-tiny-lrf":
        snake_case_ :     Union[str, Any]				=	torch.tensor([1.1669, 0.0125, -0.1695]    )
    elif model_name == "focalnet-small":
        snake_case_ :     Optional[Any]				=	torch.tensor([0.4917, -0.0430, 0.1341]    )
    elif model_name == "focalnet-small-lrf":
        snake_case_ :     Any				=	torch.tensor([-0.2588, -0.5342, -0.2331]    )
    elif model_name == "focalnet-base":
        snake_case_ :     Optional[int]				=	torch.tensor([-0.1655, -0.4090, -0.1730]    )
    elif model_name == "focalnet-base-lrf":
        snake_case_ :     int				=	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__":
     lowercase__    :  Tuple							    =	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.''',
     )

     lowercase__    :  Optional[int]							    =	parser.parse_args()
     convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)










"""simple docstring"""

import os
from datetime import datetime as dt

from github import Github


lowercase__    :  int							    =	[
    '''good first issue''',
    '''good second issue''',
    '''good difficult issue''',
    '''enhancement''',
    '''new pipeline/model''',
    '''new scheduler''',
    '''wip''',
]




def __lowercase			(							):
    snake_case_ :     Optional[Any]				=	Github(os.environ['''GITHUB_TOKEN''']    )
    snake_case_ :     Any				=	g.get_repo('''huggingface/diffusers'''    )
    snake_case_ :     Any				=	repo.get_issues(state='''open'''    )

    for issue in open_issues:
        snake_case_ :     str				=	sorted(issue.get_comments()		,			key=lambda _a    : i.created_at		,			reverse=_a    )
        snake_case_ :     Dict				=	comments[0] if len(_a    ) > 0 else None
        if (
            last_comment is not None
            and last_comment.user.login == "github-actions[bot]"
            and (dt.utcnow() - issue.updated_at).days > 7
            and (dt.utcnow() - issue.created_at).days >= 30
            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()    )
        ):
            # Closes the issue after 7 days of inactivity since the Stalebot notification.
            issue.edit(state='''closed'''    )
        elif (
            "stale" in issue.get_labels()
            and last_comment is not None
            and last_comment.user.login != "github-actions[bot]"
        ):
            # Opens the issue if someone other than Stalebot commented.
            issue.edit(state='''open'''    )
            issue.remove_from_labels('''stale'''    )
        elif (
            (dt.utcnow() - issue.updated_at).days > 23
            and (dt.utcnow() - issue.created_at).days >= 30
            and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()    )
        ):
            # Post a Stalebot notification after 23 days of inactivity.
            issue.create_comment(
                '''This issue has been automatically marked as stale because it has not had '''
                '''recent activity. If you think this still needs to be addressed '''
                '''please comment on this thread.\n\nPlease note that issues that do not follow the '''
                '''[contributing guidelines](https://github.com/huggingface/diffusers/blob/main/CONTRIBUTING.md) '''
                '''are likely to be ignored.'''    )
            issue.add_to_labels('''stale'''    )


if __name__ == "__main__":
     main()





