





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

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

   if "tiny" in model_name:
      __snake_case							       =   96
   elif "small" in model_name:
      __snake_case							       =   96
   elif "base" in model_name:
      __snake_case							       =   128
   elif "large" in model_name:
      __snake_case							       =   192
   elif "xlarge" in model_name:
      __snake_case							       =   256
   elif "huge" in model_name:
      __snake_case							       =   352

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

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

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

   if name == "norm.weight":
      __snake_case							       =   '''layernorm.weight'''
   if name == "norm.bias":
      __snake_case							       =   '''layernorm.bias'''

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

   return name






def lowerCamelCase__    (							snake_case_	:  Union[str, Any]       ,      snake_case_	:  Optional[Any]       ,      snake_case_	:  Optional[Any]=False       )      ->				Dict:
   # fmt: off
   __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

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

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

   __snake_case							       =   get_focalnet_config(snake_case_       )
   __snake_case							       =   FocalNetForImageClassification(snake_case_       )
   model.eval()

   # load state dict
   model.load_state_dict(snake_case_       )

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

   __snake_case							       =   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_       ,      )
   __snake_case							       =   Image.open(requests.get(snake_case_       ,      stream=snake_case_       ).raw       )
   __snake_case							       =   processor(images=snake_case_       ,      return_tensors='''pt'''       )

   __snake_case							       =   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							       =   image_transforms(snake_case_       ).unsqueeze(0       )

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

   __snake_case							       =   model(**snake_case_       )

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

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








from __future__ import annotations






def lowerCamelCase__    (							snake_case_	:  list[int]       ,      snake_case_	:  int       )      ->				list[list[int]]:
   __snake_case							       =   []
   __snake_case							       =   []
   __snake_case							       =   0
   __snake_case							       =   sum(snake_case_       )
   create_state_space_tree(snake_case_       ,      snake_case_       ,      snake_case_       ,      snake_case_       ,      snake_case_       ,      snake_case_       )
   return result






def lowerCamelCase__    (							snake_case_	:  list[int]       ,      snake_case_	:  int       ,      snake_case_	:  int       ,      snake_case_	:  list[int]       ,      snake_case_	:  list[list[int]]       ,      snake_case_	:  int       ,      )      ->				None:
   if sum(snake_case_       ) > max_sum or (remaining_nums_sum + sum(snake_case_       )) < max_sum:
      return
   if sum(snake_case_       ) == max_sum:
      result.append(snake_case_       )
      return
   for index in range(snake_case_       ,      len(snake_case_       )       ):
      create_state_space_tree(
          snake_case_       ,      snake_case_       ,      index + 1       ,      [*path, nums[index]]       ,      snake_case_       ,      remaining_nums_sum - nums[index]       ,      )
snake_case_				=			[3, 34, 4, 12, 5, 2]
snake_case_				=			9
snake_case_				=			generate_sum_of_subsets_soln(nums, max_sum)







print(*result)

