
"""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__		(			__snake_case	)							->		List[Any]:


					"""simple docstring"""





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

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

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

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

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

					_UpperCamelCase							 =  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	)							->		List[Any]:


					"""simple docstring"""





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

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

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

					return name



def       lowerCamelCase__		(			__snake_case,     __snake_case,     __snake_case=False	)							->		Union[str, Any]:


					"""simple docstring"""





					_UpperCamelCase							 =  {
					    '''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

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

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

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

					# load state dict
					model.load_state_dict(__snake_case	)

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

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

					_UpperCamelCase							 =  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]	),
					    ]	)

					_UpperCamelCase							 =  image_transforms(__snake_case	).unsqueeze(0	)

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

					_UpperCamelCase							 =  model(**__snake_case	)

					_UpperCamelCase							 =  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":
										_UpperCamelCase							 =  torch.tensor([0.2166, -0.4368, 0.2191]	)
					elif model_name == "focalnet-tiny-lrf":
										_UpperCamelCase							 =  torch.tensor([1.1669, 0.0125, -0.1695]	)
					elif model_name == "focalnet-small":
										_UpperCamelCase							 =  torch.tensor([0.4917, -0.0430, 0.1341]	)
					elif model_name == "focalnet-small-lrf":
										_UpperCamelCase							 =  torch.tensor([-0.2588, -0.5342, -0.2331]	)
					elif model_name == "focalnet-base":
										_UpperCamelCase							 =  torch.tensor([-0.1655, -0.4090, -0.1730]	)
					elif model_name == "focalnet-base-lrf":
										_UpperCamelCase							 =  torch.tensor([0.5306, -0.0483, -0.3928]	)
					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__":
				_a														=		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.""",
				)

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








"""simple docstring"""





def       lowerCamelCase__		(			__snake_case = 10_00	)							->		int:


					"""simple docstring"""





					_UpperCamelCase							 =  2**power
					_UpperCamelCase							 =  str(__snake_case	)
					_UpperCamelCase							 =  list(__snake_case	)
					_UpperCamelCase							 =  0

					for i in list_num:
										sum_of_num += int(__snake_case	)

					return sum_of_num


if __name__ == "__main__":
				_a														=		int(input("""Enter the power of 2: """).strip())
				print("""2 ^ """, power, """ = """, 2**power)
				_a														=		solution(power)
				print("""Sum of the digits is: """, result)






