
"""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    _lowerCAmelCase    (     lowerCamelCase__							:							List[str]				)  ->    Optional[int]:
  _SCREAMING_SNAKE_CASE   :				Tuple							    = [2, 2, 6, 2] if "tiny" in model_name else [2, 2, 1_8, 2]
  _SCREAMING_SNAKE_CASE   :				Tuple							    = True if "large" in model_name or "huge" in model_name else False
  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = True if "large" in model_name or "huge" in model_name else False
  _SCREAMING_SNAKE_CASE   :				Tuple							    = 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   :				str							    = [3, 3, 3, 3]
      _SCREAMING_SNAKE_CASE   :				int							    = [5, 5, 5, 5]
    elif "fl4" in model_name:
      _SCREAMING_SNAKE_CASE   :				int							    = [4, 4, 4, 4]
      _SCREAMING_SNAKE_CASE   :				Optional[int]							    = [3, 3, 3, 3]

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

  if "tiny" in model_name:
    _SCREAMING_SNAKE_CASE   :				Any							    = 9_6
  elif "small" in model_name:
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = 9_6
  elif "base" in model_name:
    _SCREAMING_SNAKE_CASE   :				List[str]							    = 1_2_8
  elif "large" in model_name:
    _SCREAMING_SNAKE_CASE   :				Dict							    = 1_9_2
  elif "xlarge" in model_name:
    _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = 2_5_6
  elif "huge" in model_name:
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = 3_5_2

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

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

  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = FocalNetConfig(
      embed_dim=lowerCamelCase__,						depths=lowerCamelCase__,						focal_levels=lowerCamelCase__,						focal_windows=lowerCamelCase__,						use_conv_embed=lowerCamelCase__,						idalabel=lowerCamelCase__,						labelaid=lowerCamelCase__,						use_post_layernorm=lowerCamelCase__,						use_layerscale=lowerCamelCase__,						)

  return config





def    _lowerCAmelCase    (     lowerCamelCase__							:							int				)  ->    int:
  if "patch_embed.proj" in name:
    _SCREAMING_SNAKE_CASE   :				Any							    = name.replace("patch_embed.proj",						"embeddings.patch_embeddings.projection"				)
  if "patch_embed.norm" in name:
    _SCREAMING_SNAKE_CASE   :				Tuple							    = name.replace("patch_embed.norm",						"embeddings.norm"				)
  if "layers" in name:
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = "encoder." + name
  if "encoder.layers" in name:
    _SCREAMING_SNAKE_CASE   :				int							    = name.replace("encoder.layers",						"encoder.stages"				)
  if "downsample.proj" in name:
    _SCREAMING_SNAKE_CASE   :				int							    = name.replace("downsample.proj",						"downsample.projection"				)
  if "blocks" in name:
    _SCREAMING_SNAKE_CASE   :				List[Any]							    = name.replace("blocks",						"layers"				)
  if "modulation.f.weight" in name or "modulation.f.bias" in name:
    _SCREAMING_SNAKE_CASE   :				Tuple							    = name.replace("modulation.f",						"modulation.projection_in"				)
  if "modulation.h.weight" in name or "modulation.h.bias" in name:
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = name.replace("modulation.h",						"modulation.projection_context"				)
  if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
    _SCREAMING_SNAKE_CASE   :				str							    = name.replace("modulation.proj",						"modulation.projection_out"				)

  if name == "norm.weight":
    _SCREAMING_SNAKE_CASE   :				int							    = "layernorm.weight"
  if name == "norm.bias":
    _SCREAMING_SNAKE_CASE   :				List[Any]							    = "layernorm.bias"

  if "head" in name:
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = name.replace("head",						"classifier"				)
  else:
    _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = "focalnet." + name

  return name





def    _lowerCAmelCase    (     lowerCamelCase__							:							List[Any],						lowerCamelCase__							:							Union[str, Any],						lowerCamelCase__							:							Optional[Any]=False				)  ->    Tuple:
  # fmt: off
  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = {
      "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   :				Union[str, Any]							    = model_name_to_url[model_name]
  print("Checkpoint URL: ",						lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE   :				str							    = torch.hub.load_state_dict_from_url(lowerCamelCase__,						map_location="cpu"				)["model"]

  # rename keys
  for key in state_dict.copy().keys():
    _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = state_dict.pop(lowerCamelCase__				)
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = val

  _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = get_focalnet_config(lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE   :				Tuple							    = FocalNetForImageClassification(lowerCamelCase__				)
  model.eval()

  # load state dict
  model.load_state_dict(lowerCamelCase__				)

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

  _SCREAMING_SNAKE_CASE   :				List[Any]							    = BitImageProcessor(
      do_resize=lowerCamelCase__,						size={"shortest_edge": 2_5_6},						resample=PILImageResampling.BILINEAR,						do_center_crop=lowerCamelCase__,						crop_size=2_2_4,						do_normalize=lowerCamelCase__,						image_mean=lowerCamelCase__,						image_std=lowerCamelCase__,						)
  _SCREAMING_SNAKE_CASE   :				Tuple							    = Image.open(requests.get(lowerCamelCase__,						stream=lowerCamelCase__				).raw				)
  _SCREAMING_SNAKE_CASE   :				int							    = processor(images=lowerCamelCase__,						return_tensors="pt"				)

  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = transforms.Compose(
      [
          transforms.Resize(2_5_6				),
          transforms.CenterCrop(2_2_4				),
          transforms.ToTensor(),
          transforms.Normalize(mean=[0.485, 0.456, 0.406],						std=[0.229, 0.224, 0.225]				),
      ]				)

  _SCREAMING_SNAKE_CASE   :				Any							    = image_transforms(lowerCamelCase__				).unsqueeze(0				)

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

  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = model(**lowerCamelCase__				)

  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = 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   :				Tuple							    = torch.tensor([0.2166, -0.4368, 0.2191]				)
  elif model_name == "focalnet-tiny-lrf":
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = torch.tensor([1.1669, 0.0125, -0.1695]				)
  elif model_name == "focalnet-small":
    _SCREAMING_SNAKE_CASE   :				str							    = torch.tensor([0.4917, -0.0430, 0.1341]				)
  elif model_name == "focalnet-small-lrf":
    _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = torch.tensor([-0.2588, -0.5342, -0.2331]				)
  elif model_name == "focalnet-base":
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = torch.tensor([-0.1655, -0.4090, -0.1730]				)
  elif model_name == "focalnet-base-lrf":
    _SCREAMING_SNAKE_CASE   :				int							    = torch.tensor([0.5306, -0.0483, -0.3928]				)
  assert torch.allclose(outputs.logits[0, :3],						lowerCamelCase__,						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(lowerCamelCase__				)
    processor.save_pretrained(lowerCamelCase__				)

  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_       :						Dict     					=	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_       :						List[Any]     					=	parser.parse_args()
      convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





"""simple docstring"""
from __future__ import annotations

import time
from collections.abc import Sequence
from random import randint

from matplotlib import pyplot as plt





def    _lowerCAmelCase    (     lowerCamelCase__							:							Sequence[float],						lowerCamelCase__							:							int,						lowerCamelCase__							:							int				)  ->    tuple[int | None, int | None, float]:
  if not arr:
    return None, None, 0
  if low == high:
    return low, high, arr[low]

  _SCREAMING_SNAKE_CASE   :				Any							    = (low + high) // 2
  _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				Optional[int]							    = max_subarray(lowerCamelCase__,						lowerCamelCase__,						lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				List[str]							    = max_subarray(lowerCamelCase__,						mid + 1,						lowerCamelCase__				)
  _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				str							    = max_cross_sum(lowerCamelCase__,						lowerCamelCase__,						lowerCamelCase__,						lowerCamelCase__				)
  if left_sum >= right_sum and left_sum >= cross_sum:
    return left_low, left_high, left_sum
  elif right_sum >= left_sum and right_sum >= cross_sum:
    return right_low, right_high, right_sum
  return cross_left, cross_right, cross_sum





def    _lowerCAmelCase    (     lowerCamelCase__							:							Sequence[float],						lowerCamelCase__							:							int,						lowerCamelCase__							:							int,						lowerCamelCase__							:							int				)  ->    tuple[int, int, float]:
  _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				List[Any]							    = float("-inf"				), -1
  _SCREAMING_SNAKE_CASE    ,		_SCREAMING_SNAKE_CASE   :				Dict							    = float("-inf"				), -1

  _SCREAMING_SNAKE_CASE   :				int | float							    = 0
  for i in range(lowerCamelCase__,						low - 1,						-1				):
    summ += arr[i]
    if summ > left_sum:
      _SCREAMING_SNAKE_CASE   :				int							    = summ
      _SCREAMING_SNAKE_CASE   :				Tuple							    = i

  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = 0
  for i in range(mid + 1,						high + 1				):
    summ += arr[i]
    if summ > right_sum:
      _SCREAMING_SNAKE_CASE   :				int							    = summ
      _SCREAMING_SNAKE_CASE   :				Any							    = i

  return max_left, max_right, (left_sum + right_sum)





def    _lowerCAmelCase    (     lowerCamelCase__							:							int				)  ->    float:
  _SCREAMING_SNAKE_CASE   :				Any							    = [randint(1,						lowerCamelCase__				) for _ in range(lowerCamelCase__				)]
  _SCREAMING_SNAKE_CASE   :				int							    = time.time()
  max_subarray(lowerCamelCase__,						0,						input_size - 1				)
  _SCREAMING_SNAKE_CASE   :				List[str]							    = time.time()
  return end - start





def    _lowerCAmelCase    (     )  ->    None:
  _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = [1_0, 1_0_0, 1_0_0_0, 1_0_0_0_0, 5_0_0_0_0, 1_0_0_0_0_0, 2_0_0_0_0_0, 3_0_0_0_0_0, 4_0_0_0_0_0, 5_0_0_0_0_0]
  _SCREAMING_SNAKE_CASE   :				int							    = [time_max_subarray(lowerCamelCase__				) for input_size in input_sizes]
  print("No of Inputs\t\tTime Taken"				)
  for input_size, runtime in zip(lowerCamelCase__,						lowerCamelCase__				):
    print(lowerCamelCase__,						"\t\t",						lowerCamelCase__				)
  plt.plot(lowerCamelCase__,						lowerCamelCase__				)
  plt.xlabel("Number of Inputs"				)
  plt.ylabel("Time taken in seconds"				)
  plt.show()


if __name__ == "__main__":
      from doctest import testmod

      testmod()



