




'''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 						_A      ( UpperCAmelCase						):






   '''simple docstring'''







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

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

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

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

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

   A__       =     FocalNetConfig(
       embed_dim=UpperCAmelCase      ,depths=UpperCAmelCase      ,focal_levels=UpperCAmelCase      ,focal_windows=UpperCAmelCase      ,use_conv_embed=UpperCAmelCase      ,idalabel=UpperCAmelCase      ,labelaid=UpperCAmelCase      ,use_post_layernorm=UpperCAmelCase      ,use_layerscale=UpperCAmelCase      ,)

   return config







def 						_A      ( UpperCAmelCase						):






   '''simple docstring'''







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

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

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

   return name







def 						_A      ( UpperCAmelCase      ,UpperCAmelCase      ,UpperCAmelCase=False						):






   '''simple docstring'''







   A__       =     {
       '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__       =     model_name_to_url[model_name]
   print('Checkpoint URL: '      ,UpperCAmelCase						)
   A__       =     torch.hub.load_state_dict_from_url(UpperCAmelCase      ,map_location='cpu'						)['model']

   # rename keys
   for key in state_dict.copy().keys():
      A__       =     state_dict.pop(UpperCAmelCase						)
      A__       =     val

   A__       =     get_focalnet_config(UpperCAmelCase						)
   A__       =     FocalNetForImageClassification(UpperCAmelCase						)
   model.eval()

   # load state dict
   model.load_state_dict(UpperCAmelCase						)

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

   A__       =     BitImageProcessor(
       do_resize=UpperCAmelCase      ,size={'shortest_edge': 256}      ,resample=PILImageResampling.BILINEAR      ,do_center_crop=UpperCAmelCase      ,crop_size=224      ,do_normalize=UpperCAmelCase      ,image_mean=UpperCAmelCase      ,image_std=UpperCAmelCase      ,)
   A__       =     Image.open(requests.get(UpperCAmelCase      ,stream=UpperCAmelCase						).raw						)
   A__       =     processor(images=UpperCAmelCase      ,return_tensors='pt'						)

   A__       =     transforms.Compose(
       [
           transforms.Resize(256						),
           transforms.CenterCrop(224						),
           transforms.ToTensor(),
           transforms.Normalize(mean=[0.4_85, 0.4_56, 0.4_06]      ,std=[0.2_29, 0.2_24, 0.2_25]						),
       ]						)

   A__       =     image_transforms(UpperCAmelCase						).unsqueeze(0						)

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

   A__       =     model(**UpperCAmelCase						)

   A__       =     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__       =     torch.tensor([0.21_66, -0.43_68, 0.21_91]						)
   elif model_name == "focalnet-tiny-lrf":
      A__       =     torch.tensor([1.16_69, 0.01_25, -0.16_95]						)
   elif model_name == "focalnet-small":
      A__       =     torch.tensor([0.49_17, -0.04_30, 0.13_41]						)
   elif model_name == "focalnet-small-lrf":
      A__       =     torch.tensor([-0.25_88, -0.53_42, -0.23_31]						)
   elif model_name == "focalnet-base":
      A__       =     torch.tensor([-0.16_55, -0.40_90, -0.17_30]						)
   elif model_name == "focalnet-base-lrf":
      A__       =     torch.tensor([0.53_06, -0.04_83, -0.39_28]						)
   assert torch.allclose(outputs.logits[0, :3]      ,UpperCAmelCase      ,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(UpperCAmelCase						)
      processor.save_pretrained(UpperCAmelCase						)

   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__":
    lowerCAmelCase_     						=				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.''',
    )

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








'''simple docstring'''







def 						_A      ( UpperCAmelCase						):






   '''simple docstring'''







   A__       =     0
   while num > 0:
      digit_sum += num % 10
      num //= 10
   return digit_sum







def 						_A      ( UpperCAmelCase = 100						):






   '''simple docstring'''







   A__       =     1
   A__       =     2

   for i in range(2      ,max_n + 1						):
      A__       =     pre_numerator
      A__       =     2 * i // 3 if i % 3 == 0 else 1
      A__       =     cur_numerator
      A__       =     e_cont * pre_numerator + temp

   return sum_digits(UpperCAmelCase						)


if __name__ == "__main__":
    print(f'''{solution() = }''')


