


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

 if "tiny" in model_name or "small" in model_name or "base" in model_name:
  __lowerCamelCase		:							Tuple		 =						[3, 3, 3, 3]
  if "lrf" in model_name:
   __lowerCamelCase		:							Dict		 =						[3, 3, 3, 3]
  else:
   __lowerCamelCase		:							Optional[int]		 =						[2, 2, 2, 2]

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

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

 __lowerCamelCase		:							Dict		 =						json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	repo_type='dataset'						)      ,	'r'						)						)
 __lowerCamelCase		:							Any		 =						{int(SCREAMING_SNAKE_CASE__						): v for k, v in idalabel.items()}
 __lowerCamelCase		:							Tuple		 =						{v: k for k, v in idalabel.items()}

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

 if name == "norm.weight":
  __lowerCamelCase		:							int		 =						'layernorm.weight'
 if name == "norm.bias":
  __lowerCamelCase		:							List[str]		 =						'layernorm.bias'

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

 return name
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__=False						):
 # fmt: off
 __lowerCamelCase		:							Tuple		 =						{
     '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

 __lowerCamelCase		:							Tuple		 =						model_name_to_url[model_name]
 print('Checkpoint URL: '      ,	SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							Dict		 =						torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__      ,	map_location='cpu'						)['model']

 # rename keys
 for key in state_dict.copy().keys():
  __lowerCamelCase		:							List[Any]		 =						state_dict.pop(SCREAMING_SNAKE_CASE__						)
  __lowerCamelCase		:							Union[str, Any]		 =						val

 __lowerCamelCase		:							List[Any]		 =						get_focalnet_config(SCREAMING_SNAKE_CASE__						)
 __lowerCamelCase		:							List[Any]		 =						FocalNetForImageClassification(SCREAMING_SNAKE_CASE__						)
 model.eval()

 # load state dict
 model.load_state_dict(SCREAMING_SNAKE_CASE__						)

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

 __lowerCamelCase		:							Union[str, Any]		 =						BitImageProcessor(
     do_resize=SCREAMING_SNAKE_CASE__      ,	size={'shortest_edge': 256}      ,	resample=PILImageResampling.BILINEAR      ,	do_center_crop=SCREAMING_SNAKE_CASE__      ,	crop_size=224      ,	do_normalize=SCREAMING_SNAKE_CASE__      ,	image_mean=SCREAMING_SNAKE_CASE__      ,	image_std=SCREAMING_SNAKE_CASE__      ,	)
 __lowerCamelCase		:							List[Any]		 =						Image.open(requests.get(SCREAMING_SNAKE_CASE__      ,	stream=SCREAMING_SNAKE_CASE__						).raw						)
 __lowerCamelCase		:							Optional[Any]		 =						processor(images=SCREAMING_SNAKE_CASE__      ,	return_tensors='pt'						)

 __lowerCamelCase		:							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]						),
     ]						)

 __lowerCamelCase		:							Union[str, Any]		 =						image_transforms(SCREAMING_SNAKE_CASE__						).unsqueeze(0						)

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

 __lowerCamelCase		:							Optional[Any]		 =						model(**SCREAMING_SNAKE_CASE__						)

 __lowerCamelCase		:							Tuple		 =						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":
  __lowerCamelCase		:							Union[str, Any]		 =						torch.tensor([0.2_166, -0.4_368, 0.2_191]						)
 elif model_name == "focalnet-tiny-lrf":
  __lowerCamelCase		:							List[Any]		 =						torch.tensor([1.1_669, 0.0_125, -0.1_695]						)
 elif model_name == "focalnet-small":
  __lowerCamelCase		:							Tuple		 =						torch.tensor([0.4_917, -0.0_430, 0.1_341]						)
 elif model_name == "focalnet-small-lrf":
  __lowerCamelCase		:							List[str]		 =						torch.tensor([-0.2_588, -0.5_342, -0.2_331]						)
 elif model_name == "focalnet-base":
  __lowerCamelCase		:							Tuple		 =						torch.tensor([-0.1_655, -0.4_090, -0.1_730]						)
 elif model_name == "focalnet-base-lrf":
  __lowerCamelCase		:							int		 =						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__":
       lowercase_	   =     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_	   =     parser.parse_args()
       convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





import json
import os
import tempfile

import datasets
from utils import generate_example_dataset, get_duration


lowercase_	   =     5_0_0_0_0
lowercase_	   =     5_0_0_0

lowercase_   ,lowercase_	   =     os.path.split(__file__)
lowercase_	   =     os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))
@get_duration
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 for i in range(SCREAMING_SNAKE_CASE__						):
  __lowerCamelCase		:							Tuple		 =						dataset[i]
@get_duration
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 for i in range(0      ,	len(SCREAMING_SNAKE_CASE__						)      ,	SCREAMING_SNAKE_CASE__						):
  __lowerCamelCase		:							Optional[Any]		 =						dataset[i : i + batch_size]
@get_duration
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 with dataset.formatted_as(type=SCREAMING_SNAKE_CASE__						):
  for i in range(SCREAMING_SNAKE_CASE__						):
   __lowerCamelCase		:							str		 =						dataset[i]
@get_duration
def 				UpperCamelCase__					(  SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
 with dataset.formatted_as(type=SCREAMING_SNAKE_CASE__						):
  for i in range(0      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__						):
   __lowerCamelCase		:							int		 =						dataset[i : i + batch_size]
def 				UpperCamelCase__					(  ):
 __lowerCamelCase		:							Union[str, Any]		 =						{'num examples': SPEED_TEST_N_EXAMPLES}
 __lowerCamelCase		:							Optional[Any]		 =						[
     (read, {'length': SMALL_TEST}),
     (read, {'length': SPEED_TEST_N_EXAMPLES}),
     (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}),
     (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}),
     (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}),
     (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}),
     (read_formatted, {'type': 'pandas', 'length': SMALL_TEST}),
     (read_formatted, {'type': 'torch', 'length': SMALL_TEST}),
     (read_formatted, {'type': 'tensorflow', 'length': SMALL_TEST}),
     (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}),
     (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}),
 ]

 __lowerCamelCase		:							Any		 =						[
     (read, {'length': SMALL_TEST}),
     (read, {'length': SPEED_TEST_N_EXAMPLES}),
     (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 10}),
     (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 100}),
     (read_batch, {'length': SPEED_TEST_N_EXAMPLES, 'batch_size': 1_000}),
     (read_formatted, {'type': 'numpy', 'length': SMALL_TEST}),
     (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 10}),
     (read_formatted_batch, {'type': 'numpy', 'length': SMALL_TEST, 'batch_size': 1_000}),
 ]
 with tempfile.TemporaryDirectory() as tmp_dir:
  print('generating dataset'						)
  __lowerCamelCase		:							Optional[int]		 =						datasets.Features(
      {'list': datasets.Sequence(datasets.Value('float32'						)						), 'numbers': datasets.Value('float32'						)}						)
  __lowerCamelCase		:							str		 =						generate_example_dataset(
      os.path.join(SCREAMING_SNAKE_CASE__      ,	'dataset.arrow'						)      ,	SCREAMING_SNAKE_CASE__      ,	num_examples=SCREAMING_SNAKE_CASE__      ,	seq_shapes={'list': (100,)}      ,	)
  print('first set of iterations'						)
  for func, kwargs in functions:
   print(func.__name__      ,	str(SCREAMING_SNAKE_CASE__						)						)
   __lowerCamelCase		:							Optional[int]		 =						func(SCREAMING_SNAKE_CASE__      ,	**SCREAMING_SNAKE_CASE__						)

  print('shuffling dataset'						)
  __lowerCamelCase		:							str		 =						dataset.shuffle()
  print('Second set of iterations (after shuffling'						)
  for func, kwargs in functions_shuffled:
   print('shuffled '      ,	func.__name__      ,	str(SCREAMING_SNAKE_CASE__						)						)
   __lowerCamelCase		:							int		 =						func(
       SCREAMING_SNAKE_CASE__      ,	**SCREAMING_SNAKE_CASE__						)

 with open(SCREAMING_SNAKE_CASE__      ,	'wb'						) as f:
  f.write(json.dumps(SCREAMING_SNAKE_CASE__						).encode('utf-8'						)						)


if __name__ == "__main__":  # useful to run the profiler
       benchmark_iterating()

