





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


      '''simple docstring'''


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

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

      if "tiny" in model_name:
            SCREAMING_SNAKE_CASE	=		96
      elif "small" in model_name:
            SCREAMING_SNAKE_CASE	=		96
      elif "base" in model_name:
            SCREAMING_SNAKE_CASE	=		1_28
      elif "large" in model_name:
            SCREAMING_SNAKE_CASE	=		1_92
      elif "xlarge" in model_name:
            SCREAMING_SNAKE_CASE	=		2_56
      elif "huge" in model_name:
            SCREAMING_SNAKE_CASE	=		3_52

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

      SCREAMING_SNAKE_CASE	=		json.load(open(hf_hub_download(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		repo_type="""dataset"""			)				,		"""r"""			)			)
      SCREAMING_SNAKE_CASE	=		{int(_SCREAMING_SNAKE_CASE			): v for k, v in idalabel.items()}
      SCREAMING_SNAKE_CASE	=		{v: k for k, v in idalabel.items()}

      SCREAMING_SNAKE_CASE	=		FocalNetConfig(
          embed_dim=_SCREAMING_SNAKE_CASE				,		depths=_SCREAMING_SNAKE_CASE				,		focal_levels=_SCREAMING_SNAKE_CASE				,		focal_windows=_SCREAMING_SNAKE_CASE				,		use_conv_embed=_SCREAMING_SNAKE_CASE				,		idalabel=_SCREAMING_SNAKE_CASE				,		labelaid=_SCREAMING_SNAKE_CASE				,		use_post_layernorm=_SCREAMING_SNAKE_CASE				,		use_layerscale=_SCREAMING_SNAKE_CASE				,		)

      return config



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     Optional[int]:


      '''simple docstring'''


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

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

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

      return name



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE=False			)				->     Dict:


      '''simple docstring'''


      SCREAMING_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

      SCREAMING_SNAKE_CASE	=		model_name_to_url[model_name]
      print("""Checkpoint URL: """				,		_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		torch.hub.load_state_dict_from_url(_SCREAMING_SNAKE_CASE				,		map_location="""cpu"""			)["""model"""]

      # rename keys
      for key in state_dict.copy().keys():
            SCREAMING_SNAKE_CASE	=		state_dict.pop(_SCREAMING_SNAKE_CASE			)
            SCREAMING_SNAKE_CASE	=		val

      SCREAMING_SNAKE_CASE	=		get_focalnet_config(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		FocalNetForImageClassification(_SCREAMING_SNAKE_CASE			)
      model.eval()

      # load state dict
      model.load_state_dict(_SCREAMING_SNAKE_CASE			)

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

      SCREAMING_SNAKE_CASE	=		BitImageProcessor(
          do_resize=_SCREAMING_SNAKE_CASE				,		size={"""shortest_edge""": 2_56}				,		resample=PILImageResampling.BILINEAR				,		do_center_crop=_SCREAMING_SNAKE_CASE				,		crop_size=2_24				,		do_normalize=_SCREAMING_SNAKE_CASE				,		image_mean=_SCREAMING_SNAKE_CASE				,		image_std=_SCREAMING_SNAKE_CASE				,		)
      SCREAMING_SNAKE_CASE	=		Image.open(requests.get(_SCREAMING_SNAKE_CASE				,		stream=_SCREAMING_SNAKE_CASE			).raw			)
      SCREAMING_SNAKE_CASE	=		processor(images=_SCREAMING_SNAKE_CASE				,		return_tensors="""pt"""			)

      SCREAMING_SNAKE_CASE	=		transforms.Compose(
          [
              transforms.Resize(2_56			),
              transforms.CenterCrop(2_24			),
              transforms.ToTensor(),
              transforms.Normalize(mean=[0.485, 0.456, 0.406]				,		std=[0.229, 0.224, 0.225]			),
          ]			)

      SCREAMING_SNAKE_CASE	=		image_transforms(_SCREAMING_SNAKE_CASE			).unsqueeze(0			)

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

      SCREAMING_SNAKE_CASE	=		model(**_SCREAMING_SNAKE_CASE			)

      SCREAMING_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":
            SCREAMING_SNAKE_CASE	=		torch.tensor([0.2_166, -0.4_368, 0.2_191]			)
      elif model_name == "focalnet-tiny-lrf":
            SCREAMING_SNAKE_CASE	=		torch.tensor([1.1_669, 0.0_125, -0.1_695]			)
      elif model_name == "focalnet-small":
            SCREAMING_SNAKE_CASE	=		torch.tensor([0.4_917, -0.0_430, 0.1_341]			)
      elif model_name == "focalnet-small-lrf":
            SCREAMING_SNAKE_CASE	=		torch.tensor([-0.2_588, -0.5_342, -0.2_331]			)
      elif model_name == "focalnet-base":
            SCREAMING_SNAKE_CASE	=		torch.tensor([-0.1_655, -0.4_090, -0.1_730]			)
      elif model_name == "focalnet-base-lrf":
            SCREAMING_SNAKE_CASE	=		torch.tensor([0.5_306, -0.0_483, -0.3_928]			)
      assert torch.allclose(outputs.logits[0, :3]				,		_SCREAMING_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(_SCREAMING_SNAKE_CASE			)
            processor.save_pretrained(_SCREAMING_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__":
      SCREAMING_SNAKE_CASE_		     = 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.""",
      )

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









import os
from datetime import datetime as dt

from github import Github


SCREAMING_SNAKE_CASE_		     = [
    """good first issue""",
    """feature request""",
    """wip""",
]



def      __lowercase     (   )				->     Optional[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		Github(os.environ["""GITHUB_TOKEN"""]			)
      SCREAMING_SNAKE_CASE	=		g.get_repo("""huggingface/accelerate"""			)
      SCREAMING_SNAKE_CASE	=		repo.get_issues(state="""open"""			)

      for issue in open_issues:
            SCREAMING_SNAKE_CASE	=		sorted([comment for comment in issue.get_comments()]				,		key=lambda _SCREAMING_SNAKE_CASE			: i.created_at				,		reverse=_SCREAMING_SNAKE_CASE			)
            SCREAMING_SNAKE_CASE	=		comments[0] if len(_SCREAMING_SNAKE_CASE			) > 0 else None
            SCREAMING_SNAKE_CASE	=		dt.utcnow()
            SCREAMING_SNAKE_CASE	=		(current_time - issue.updated_at).days
            SCREAMING_SNAKE_CASE	=		(current_time - issue.created_at).days
            if (
                last_comment is not None
                and last_comment.user.login == "github-actions[bot]"
                and days_since_updated > 7
                and days_since_creation >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
            ):
                  # Close issue since it has been 7 days of inactivity since bot mention.
                  issue.edit(state="""closed"""			)
            elif (
                days_since_updated > 23
                and days_since_creation >= 30
                and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels()			)
            ):
                  # Add stale comment
                  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/accelerate/blob/main/CONTRIBUTING.md) """
                      """are likely to be ignored."""			)


if __name__ == "__main__":
      main()


