






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

				if "tiny" in model_name or "small" in model_name or "base" in model_name:
								a_		:  List[Any]											=      [3, 3, 3, 3]
								if "lrf" in model_name:
												a_		:  List[str]											=      [3, 3, 3, 3]
								else:
												a_		:  int											=      [2, 2, 2, 2]

				if "tiny" in model_name:
								a_		:  Any											=      96
				elif "small" in model_name:
								a_		:  int											=      96
				elif "base" in model_name:
								a_		:  Any											=      1_28
				elif "large" in model_name:
								a_		:  Union[str, Any]											=      1_92
				elif "xlarge" in model_name:
								a_		:  Optional[Any]											=      2_56
				elif "huge" in model_name:
								a_		:  Optional[int]											=      3_52

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

				a_		:  Optional[int]											=      json.load(open(hf_hub_download(__A						,		__A						,		repo_type='''dataset'''      )						,		'''r'''      )      )
				a_		:  Optional[Any]											=      {int(__A      ): v for k, v in idalabel.items()}
				a_		:  Union[str, Any]											=      {v: k for k, v in idalabel.items()}

				a_		:  List[str]											=      FocalNetConfig(
				    embed_dim=__A						,		depths=__A						,		focal_levels=__A						,		focal_windows=__A						,		use_conv_embed=__A						,		idalabel=__A						,		labelaid=__A						,		use_post_layernorm=__A						,		use_layerscale=__A						,		)

				return config





def 		_UpperCAmelCase   (							__A							:   Tuple      ):
				if "patch_embed.proj" in name:
								a_		:  Dict											=      name.replace('''patch_embed.proj'''						,		'''embeddings.patch_embeddings.projection'''      )
				if "patch_embed.norm" in name:
								a_		:  Optional[int]											=      name.replace('''patch_embed.norm'''						,		'''embeddings.norm'''      )
				if "layers" in name:
								a_		:  Tuple											=      '''encoder.''' + name
				if "encoder.layers" in name:
								a_		:  str											=      name.replace('''encoder.layers'''						,		'''encoder.stages'''      )
				if "downsample.proj" in name:
								a_		:  Optional[Any]											=      name.replace('''downsample.proj'''						,		'''downsample.projection'''      )
				if "blocks" in name:
								a_		:  Optional[Any]											=      name.replace('''blocks'''						,		'''layers'''      )
				if "modulation.f.weight" in name or "modulation.f.bias" in name:
								a_		:  Dict											=      name.replace('''modulation.f'''						,		'''modulation.projection_in'''      )
				if "modulation.h.weight" in name or "modulation.h.bias" in name:
								a_		:  Optional[Any]											=      name.replace('''modulation.h'''						,		'''modulation.projection_context'''      )
				if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
								a_		:  int											=      name.replace('''modulation.proj'''						,		'''modulation.projection_out'''      )

				if name == "norm.weight":
								a_		:  Dict											=      '''layernorm.weight'''
				if name == "norm.bias":
								a_		:  List[str]											=      '''layernorm.bias'''

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

				return name





def 		_UpperCAmelCase   (							__A							:   List[Any]						,		__A							:   Optional[Any]						,		__A							:   str=False      ):
				# fmt: off
				a_		:  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

				a_		:  Any											=      model_name_to_url[model_name]
				print('''Checkpoint URL: '''						,		__A      )
				a_		:  Optional[Any]											=      torch.hub.load_state_dict_from_url(__A						,		map_location='''cpu'''      )['''model''']

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

				a_		:  Tuple											=      get_focalnet_config(__A      )
				a_		:  str											=      FocalNetForImageClassification(__A      )
				model.eval()

				# load state dict
				model.load_state_dict(__A      )

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

				a_		:  Any											=      BitImageProcessor(
				    do_resize=__A						,		size={'''shortest_edge''': 2_56}						,		resample=PILImageResampling.BILINEAR						,		do_center_crop=__A						,		crop_size=2_24						,		do_normalize=__A						,		image_mean=__A						,		image_std=__A						,		)
				a_		:  Optional[int]											=      Image.open(requests.get(__A						,		stream=__A      ).raw      )
				a_		:  Optional[Any]											=      processor(images=__A						,		return_tensors='''pt'''      )

				a_		:  Union[str, Any]											=      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]      ),
				    ]      )

				a_		:  int											=      image_transforms(__A      ).unsqueeze(0      )

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

				a_		:  List[str]											=      model(**__A      )

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

				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'''







import requests
from bsa import BeautifulSoup





def 		_UpperCAmelCase   (							__A							:   str						,		__A							:   dict      ):
				a_		:  Tuple											=      BeautifulSoup(requests.get(__A						,		params=__A      ).content						,		'''html.parser'''      )
				a_		:  List[str]											=      soup.find('''div'''						,		attrs={'''class''': '''gs_ri'''}      )
				a_		:  List[str]											=      div.find('''div'''						,		attrs={'''class''': '''gs_fl'''}      ).find_all('''a'''      )
				return anchors[2].get_text()


if __name__ == "__main__":
		__lowerCAmelCase       		=      {
		    'title': (
		        'Precisely geometry controlled microsupercapacitors for ultrahigh areal '
		        'capacitance, volumetric capacitance, and energy density'
		    ),
		    'journal': 'Chem. Mater.',
		    'volume': 30,
		    'pages': '3979-3990',
		    'year': 2_018,
		    'hl': 'en',
		}
		print(get_citation('https://scholar.google.com/scholar_lookup', params=params))




