


'''simple docstring'''
import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__snake_case          =  logging.get_logger(__name__)


def     a   (    __a				,      __a=False     )						->			int:



					'''simple docstring'''






					UpperCamelCase__     :Optional[int]							      =				[]

					# fmt: off
					# stem:
					rename_keys.append(('''cls_token''', '''vit.embeddings.cls_token''')     )
					rename_keys.append(('''pos_embed''', '''vit.embeddings.position_embeddings''')     )

					rename_keys.append(('''patch_embed.proj.weight''', '''vit.embeddings.patch_embeddings.projection.weight''')     )
					rename_keys.append(('''patch_embed.proj.bias''', '''vit.embeddings.patch_embeddings.projection.bias''')     )

					# backbone
					rename_keys.append(('''patch_embed.backbone.stem.conv.weight''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight''')     )
					rename_keys.append(('''patch_embed.backbone.stem.norm.weight''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight''')     )
					rename_keys.append(('''patch_embed.backbone.stem.norm.bias''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias''')     )

					for stage_idx in range(len(config.backbone_config.depths     )     ):
										for layer_idx in range(config.backbone_config.depths[stage_idx]     ):
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight''')     )
															rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias''')     )

										rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight''')     )
										rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight''')     )
										rename_keys.append((f'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias''', f'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias''')     )

					# transformer encoder
					for i in range(config.num_hidden_layers     ):
										# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
										rename_keys.append((f'''blocks.{i}.norm1.weight''', f'''vit.encoder.layer.{i}.layernorm_before.weight''')     )
										rename_keys.append((f'''blocks.{i}.norm1.bias''', f'''vit.encoder.layer.{i}.layernorm_before.bias''')     )
										rename_keys.append((f'''blocks.{i}.attn.proj.weight''', f'''vit.encoder.layer.{i}.attention.output.dense.weight''')     )
										rename_keys.append((f'''blocks.{i}.attn.proj.bias''', f'''vit.encoder.layer.{i}.attention.output.dense.bias''')     )
										rename_keys.append((f'''blocks.{i}.norm2.weight''', f'''vit.encoder.layer.{i}.layernorm_after.weight''')     )
										rename_keys.append((f'''blocks.{i}.norm2.bias''', f'''vit.encoder.layer.{i}.layernorm_after.bias''')     )
										rename_keys.append((f'''blocks.{i}.mlp.fc1.weight''', f'''vit.encoder.layer.{i}.intermediate.dense.weight''')     )
										rename_keys.append((f'''blocks.{i}.mlp.fc1.bias''', f'''vit.encoder.layer.{i}.intermediate.dense.bias''')     )
										rename_keys.append((f'''blocks.{i}.mlp.fc2.weight''', f'''vit.encoder.layer.{i}.output.dense.weight''')     )
										rename_keys.append((f'''blocks.{i}.mlp.fc2.bias''', f'''vit.encoder.layer.{i}.output.dense.bias''')     )

					if base_model:
										# layernorm + pooler
										rename_keys.extend(
										    [
										        ('''norm.weight''', '''layernorm.weight'''),
										        ('''norm.bias''', '''layernorm.bias'''),
										        ('''pre_logits.fc.weight''', '''pooler.dense.weight'''),
										        ('''pre_logits.fc.bias''', '''pooler.dense.bias'''),
										    ]     )

										# if just the base model, we should remove "vit" from all keys that start with "vit"
										UpperCamelCase__     :Any							      =				[(pair[0], pair[1][4:]) if pair[1].startswith('''vit'''     ) else pair for pair in rename_keys]
					else:
										# layernorm + classification head
										rename_keys.extend(
										    [
										        ('''norm.weight''', '''vit.layernorm.weight'''),
										        ('''norm.bias''', '''vit.layernorm.bias'''),
										        ('''head.weight''', '''classifier.weight'''),
										        ('''head.bias''', '''classifier.bias'''),
										    ]     )
					# fmt: on

					return rename_keys


def     a   (    __a				,      __a				,      __a=False     )						->			Tuple:



					'''simple docstring'''






					for i in range(config.num_hidden_layers     ):
										if base_model:
															UpperCamelCase__     :Any							      =				''''''
										else:
															UpperCamelCase__     :List[str]							      =				'''vit.'''
										# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
										UpperCamelCase__     :Optional[Any]							      =				state_dict.pop(f'''blocks.{i}.attn.qkv.weight'''     )
										UpperCamelCase__     :Tuple							      =				state_dict.pop(f'''blocks.{i}.attn.qkv.bias'''     )
										# next, add query, keys and values (in that order) to the state dict
										UpperCamelCase__     :int							      =				in_proj_weight[
										    : config.hidden_size, :
										]
										UpperCamelCase__     :int							      =				in_proj_bias[: config.hidden_size]
										UpperCamelCase__     :int							      =				in_proj_weight[
										    config.hidden_size : config.hidden_size * 2, :
										]
										UpperCamelCase__     :int							      =				in_proj_bias[
										    config.hidden_size : config.hidden_size * 2
										]
										UpperCamelCase__     :Tuple							      =				in_proj_weight[
										    -config.hidden_size :, :
										]
										UpperCamelCase__     :str							      =				in_proj_bias[-config.hidden_size :]


def     a   (    __a     )						->			int:



					'''simple docstring'''






					UpperCamelCase__     :Optional[Any]							      =				['''head.weight''', '''head.bias''']
					for k in ignore_keys:
										state_dict.pop(__a				,      __a     )


def     a   (    __a				,      __a				,      __a     )						->			Optional[Any]:



					'''simple docstring'''






					UpperCamelCase__     :Optional[Any]							      =				dct.pop(__a     )
					UpperCamelCase__     :Any							      =				val


def     a   (    )						->			Dict:



					'''simple docstring'''






					UpperCamelCase__     :int							      =				'''http://images.cocodataset.org/val2017/000000039769.jpg'''
					UpperCamelCase__     :int							      =				Image.open(requests.get(__a				,      stream=__a     ).raw     )
					return im


@torch.no_grad()
def     a   (    __a				,      __a				,      __a=False     )						->			int:



					'''simple docstring'''






					UpperCamelCase__     :Optional[Any]							      =				BitConfig(
					    global_padding='''same'''				,      layer_type='''bottleneck'''				,      depths=(3, 4, 9)				,      out_features=['''stage3''']				,      embedding_dynamic_padding=__a				,      )
					UpperCamelCase__     :List[Any]							      =				ViTHybridConfig(backbone_config=__a				,      image_size=384				,      num_labels=1000     )
					UpperCamelCase__     :Tuple							      =				False

					# load original model from timm
					UpperCamelCase__     :Dict							      =				timm.create_model(__a				,      pretrained=__a     )
					timm_model.eval()

					# load state_dict of original model, remove and rename some keys
					UpperCamelCase__     :Tuple							      =				timm_model.state_dict()
					if base_model:
										remove_classification_head_(__a     )
					UpperCamelCase__     :List[str]							      =				create_rename_keys(__a				,      __a     )
					for src, dest in rename_keys:
										rename_key(__a				,      __a				,      __a     )
					read_in_q_k_v(__a				,      __a				,      __a     )

					UpperCamelCase__     :Dict							      =				'''huggingface/label-files'''
					UpperCamelCase__     :str							      =				'''imagenet-1k-id2label.json'''
					UpperCamelCase__     :Dict							      =				json.load(open(hf_hub_download(__a				,      __a				,      repo_type='''dataset'''     )				,      '''r'''     )     )
					UpperCamelCase__     :Any							      =				{int(__a     ): v for k, v in idalabel.items()}
					UpperCamelCase__     :str							      =				idalabel
					UpperCamelCase__     :Any							      =				{v: k for k, v in idalabel.items()}

					# load HuggingFace model
					if vit_name[-5:] == "in21k":
										UpperCamelCase__     :List[Any]							      =				ViTHybridModel(__a     ).eval()
					else:
										UpperCamelCase__     :Optional[int]							      =				ViTHybridForImageClassification(__a     ).eval()
					model.load_state_dict(__a     )

					# create image processor
					UpperCamelCase__     :str							      =				create_transform(**resolve_data_config({}				,      model=__a     )     )
					UpperCamelCase__     :Optional[Any]							      =				transform.transforms

					UpperCamelCase__     :Optional[Any]							      =				{
					    '''bilinear''': PILImageResampling.BILINEAR,
					    '''bicubic''': PILImageResampling.BICUBIC,
					    '''nearest''': PILImageResampling.NEAREST,
					}

					UpperCamelCase__     :str							      =				ViTHybridImageProcessor(
					    do_resize=__a				,      size={'''shortest_edge''': timm_transforms[0].size}				,      resample=pillow_resamplings[timm_transforms[0].interpolation.value]				,      do_center_crop=__a				,      crop_size={'''height''': timm_transforms[1].size[0], '''width''': timm_transforms[1].size[1]}				,      do_normalize=__a				,      image_mean=timm_transforms[-1].mean.tolist()				,      image_std=timm_transforms[-1].std.tolist()				,      )

					UpperCamelCase__     :List[Any]							      =				prepare_img()
					UpperCamelCase__     :int							      =				transform(__a     ).unsqueeze(0     )
					UpperCamelCase__     :Tuple							      =				processor(__a				,      return_tensors='''pt'''     ).pixel_values

					# verify pixel values
					assert torch.allclose(__a				,      __a     )

					# verify logits
					with torch.no_grad():
										UpperCamelCase__     :Optional[Any]							      =				model(__a     )
										UpperCamelCase__     :Tuple							      =				outputs.logits

					print('''Predicted class:'''				,      logits.argmax(-1     ).item()     )
					if base_model:
										UpperCamelCase__     :List[str]							      =				timm_model.forward_features(__a     )
										assert timm_pooled_output.shape == outputs.pooler_output.shape
										assert torch.allclose(__a				,      outputs.pooler_output				,      atol=1e-3     )
					else:
										UpperCamelCase__     :List[Any]							      =				timm_model(__a     )
										assert timm_logits.shape == outputs.logits.shape
										assert torch.allclose(__a				,      outputs.logits				,      atol=1e-3     )
					print('''Looks ok!'''     )

					if pytorch_dump_folder_path is not None:
										Path(__a     ).mkdir(exist_ok=__a     )
										print(f'''Saving model {vit_name} to {pytorch_dump_folder_path}'''     )
										model.save_pretrained(__a     )
										print(f'''Saving processor to {pytorch_dump_folder_path}'''     )
										processor.save_pretrained(__a     )

					if push_to_hub:
										print(f'''Pushing model and processor to the hub {vit_name}'''     )
										model.push_to_hub(f'''ybelkada/{vit_name}'''     )
										processor.push_to_hub(f'''ybelkada/{vit_name}'''     )


if __name__ == "__main__":
		__snake_case          =  argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--vit_name''',
		    default='''vit_base_r50_s16_384''',
		    type=str,
		    help='''Name of the hybrid ViT timm 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 upload the model to the HuggingFace hub.'''
		)

		__snake_case          =  parser.parse_args()
		convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)



'''simple docstring'''
import sys

__snake_case							   =  (
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)


def     a   (    __a     )						->			int:



					'''simple docstring'''






					UpperCamelCase__     :Tuple							      =				1
					for digit in s:
										product *= int(__a     )
					return product


def     a   (    __a = N     )						->			int:



					'''simple docstring'''






					UpperCamelCase__     :Tuple							      =				-sys.maxsize - 1
					UpperCamelCase__     :Dict							      =				n[:13]
					UpperCamelCase__     :Dict							      =				13
					while cur_index < len(__a     ) - 13:
										if int(n[cur_index]     ) >= int(substr[0]     ):
															UpperCamelCase__     :Dict							      =				substr[1:] + n[cur_index]
															cur_index += 1
										else:
															UpperCamelCase__     :List[str]							      =				max(__a				,      str_eval(__a     )     )
															UpperCamelCase__     :Union[str, Any]							      =				n[cur_index : cur_index + 13]
															cur_index += 13
					return largest_product


if __name__ == "__main__":
		print(F"""{solution() = }""")