




'''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 						snake_case_       (UpperCamelCase			:    Optional[Any] ):





							'''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 						snake_case_       (UpperCamelCase			:    Optional[Any] ):





							'''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 						snake_case_       (UpperCamelCase			:    Tuple					,		UpperCamelCase			:    Union[str, Any]					,		UpperCamelCase			:    Optional[Any]=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.485, 0.456, 0.406]					,		std=[0.229, 0.224, 0.225] ),
							    ] )

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

				_snake_case : Optional[int]  				=						parser.parse_args()
				convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







'''simple docstring'''


from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass

@dataclass
class      A       :
							lowercase_							     =							42
							lowercase_							     =							42



class      A       :







							def __init__(    self			:    Optional[Any]				,     lowerCAmelCase_			:    int   )     ->				str:


														"""simple docstring"""


														_a      	=							[[] for _ in range(lowerCAmelCase_   )]
														_a      	=							size







							def __getitem__(    self			:    Any				,     lowerCAmelCase_			:    int   )     ->				Iterator[Edge]:


														"""simple docstring"""


														return iter(self._graph[vertex]   )







							@property
							def   __lowerCAmelCase     (    self			:    str   )     ->				Tuple:


														"""simple docstring"""


														return self._size







							def   __lowerCAmelCase     (    self			:    Union[str, Any]				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    int   )     ->				Dict:


														"""simple docstring"""


														if weight not in (0, 1):
																					raise ValueError('''Edge weight must be either 0 or 1.'''   )

														if to_vertex < 0 or to_vertex >= self.size:
																					raise ValueError('''Vertex indexes must be in [0; size).'''   )

														self._graph[from_vertex].append(Edge(lowerCAmelCase_				,     lowerCAmelCase_   )   )







							def   __lowerCAmelCase     (    self			:    Tuple				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    int   )     ->				int | None:


														"""simple docstring"""


														_a      	=							deque([start_vertex]   )
														_a      	=							[None] * self.size
														_a      	=							0

														while queue:
																					_a      	=							queue.popleft()
																					_a      	=							distances[current_vertex]
																					if current_distance is None:
																												continue

																					for edge in self[current_vertex]:
																												_a      	=							current_distance + edge.weight
																												_a      	=							distances[edge.destination_vertex]
																												if (
																												    isinstance(lowerCAmelCase_				,     lowerCAmelCase_   )
																												    and new_distance >= dest_vertex_distance
																												):
																																			continue
																												_a      	=							new_distance
																												if edge.weight == 0:
																																			queue.appendleft(edge.destination_vertex   )
																												else:
																																			queue.append(edge.destination_vertex   )

														if distances[finish_vertex] is None:
																					raise ValueError('''No path from start_vertex to finish_vertex.'''   )

														return distances[finish_vertex]


if __name__ == "__main__":
				import doctest

				doctest.testmod()

