






'''simple docstring'''







import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase    :      Tuple  			=		logging.get_logger(__name__)
def 						A__			(				__lowerCAmelCase   ,    __lowerCAmelCase=False   ,    __lowerCAmelCase=False						):
						lowerCamelCase__         =  """backbone.""" if is_semantic else """"""

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

						# projection layer + position embeddings
						rename_keys.extend(
						    [
						        (F'''{prefix}cls_token''', """beit.embeddings.cls_token"""),
						        (F'''{prefix}patch_embed.proj.weight''', """beit.embeddings.patch_embeddings.projection.weight"""),
						        (F'''{prefix}patch_embed.proj.bias''', """beit.embeddings.patch_embeddings.projection.bias"""),
						        (F'''{prefix}pos_embed''', """beit.embeddings.position_embeddings"""),
						    ]						)

						if has_lm_head:
												# mask token + layernorm
												rename_keys.extend(
												    [
												        ("""mask_token""", """beit.embeddings.mask_token"""),
												        ("""norm.weight""", """layernorm.weight"""),
												        ("""norm.bias""", """layernorm.bias"""),
												    ]						)
						else:
												# layernorm + classification head
												rename_keys.extend(
												    [
												        ("""fc_norm.weight""", """beit.pooler.layernorm.weight"""),
												        ("""fc_norm.bias""", """beit.pooler.layernorm.bias"""),
												        ("""head.weight""", """classifier.weight"""),
												        ("""head.bias""", """classifier.bias"""),
												    ]						)

						return rename_keys
def 						A__			(				__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase=False   ,    __lowerCAmelCase=False						):
						for i in range(config.num_hidden_layers						):
												lowerCamelCase__         =  """backbone.""" if is_semantic else """"""
												# queries, keys and values
												lowerCamelCase__         =  state_dict.pop(F'''{prefix}blocks.{i}.attn.qkv.weight'''						)
												lowerCamelCase__         =  state_dict.pop(F'''{prefix}blocks.{i}.attn.q_bias'''						)
												lowerCamelCase__         =  state_dict.pop(F'''{prefix}blocks.{i}.attn.v_bias'''						)

												lowerCamelCase__         =  in_proj_weight[
												    : config.hidden_size, :
												]
												lowerCamelCase__         =  q_bias
												lowerCamelCase__         =  in_proj_weight[
												    config.hidden_size : config.hidden_size * 2, :
												]
												lowerCamelCase__         =  in_proj_weight[
												    -config.hidden_size :, :
												]
												lowerCamelCase__         =  v_bias

												# gamma_1 and gamma_2
												# we call them lambda because otherwise they are renamed when using .from_pretrained
												lowerCamelCase__         =  state_dict.pop(F'''{prefix}blocks.{i}.gamma_1'''						)
												lowerCamelCase__         =  state_dict.pop(F'''{prefix}blocks.{i}.gamma_2'''						)

												lowerCamelCase__         =  gamma_a
												lowerCamelCase__         =  gamma_a
def 						A__			(				__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase						):
						lowerCamelCase__         =  dct.pop(__lowerCAmelCase						)
						lowerCamelCase__         =  val
def 						A__			(				):
						lowerCamelCase__         =  """http://images.cocodataset.org/val2017/000000039769.jpg"""
						lowerCamelCase__         =  Image.open(requests.get(__lowerCAmelCase   ,    stream=__lowerCAmelCase						).raw						)
						return im
@torch.no_grad()
def 						A__			(				__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase=False						):
						lowerCamelCase__         =  False if """rvlcdip""" in checkpoint_url else True
						lowerCamelCase__         =  BeitConfig(use_absolute_position_embeddings=__lowerCAmelCase   ,    use_mask_token=__lowerCAmelCase						)

						# size of the architecture
						if "large" in checkpoint_url or "dit-l" in checkpoint_url:
												lowerCamelCase__         =  1024
												lowerCamelCase__         =  4096
												lowerCamelCase__         =  24
												lowerCamelCase__         =  16

						# labels
						if "rvlcdip" in checkpoint_url:
												lowerCamelCase__         =  16
												lowerCamelCase__         =  """huggingface/label-files"""
												lowerCamelCase__         =  """rvlcdip-id2label.json"""
												lowerCamelCase__         =  json.load(open(hf_hub_download(__lowerCAmelCase   ,    __lowerCAmelCase   ,    repo_type="""dataset"""						)   ,    """r"""						)						)
												lowerCamelCase__         =  {int(__lowerCAmelCase						): v for k, v in idalabel.items()}
												lowerCamelCase__         =  idalabel
												lowerCamelCase__         =  {v: k for k, v in idalabel.items()}

						# load state_dict of original model, remove and rename some keys
						lowerCamelCase__         =  torch.hub.load_state_dict_from_url(__lowerCAmelCase   ,    map_location="""cpu"""						)["""model"""]

						lowerCamelCase__         =  create_rename_keys(__lowerCAmelCase   ,    has_lm_head=__lowerCAmelCase						)
						for src, dest in rename_keys:
												rename_key(__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase						)
						read_in_q_k_v(__lowerCAmelCase   ,    __lowerCAmelCase   ,    has_lm_head=__lowerCAmelCase						)

						# load HuggingFace model
						lowerCamelCase__         =  BeitForMaskedImageModeling(__lowerCAmelCase						) if has_lm_head else BeitForImageClassification(__lowerCAmelCase						)
						model.eval()
						model.load_state_dict(__lowerCAmelCase						)

						# Check outputs on an image
						lowerCamelCase__         =  BeitImageProcessor(
						    size=config.image_size   ,    resample=PILImageResampling.BILINEAR   ,    do_center_crop=__lowerCAmelCase						)
						lowerCamelCase__         =  prepare_img()

						lowerCamelCase__         =  image_processor(images=__lowerCAmelCase   ,    return_tensors="""pt"""						)
						lowerCamelCase__         =  encoding["""pixel_values"""]

						lowerCamelCase__         =  model(__lowerCAmelCase						)
						lowerCamelCase__         =  outputs.logits

						# verify logits
						lowerCamelCase__         =  [1, 16] if """rvlcdip""" in checkpoint_url else [1, 196, 8192]
						assert logits.shape == torch.Size(__lowerCAmelCase						), "Shape of logits not as expected"

						Path(__lowerCAmelCase						).mkdir(exist_ok=__lowerCAmelCase						)
						print(F'''Saving model to {pytorch_dump_folder_path}'''						)
						model.save_pretrained(__lowerCAmelCase						)
						print(F'''Saving image processor to {pytorch_dump_folder_path}'''						)
						image_processor.save_pretrained(__lowerCAmelCase						)

						if push_to_hub:
												if has_lm_head:
																		lowerCamelCase__         =  """dit-base""" if """base""" in checkpoint_url else """dit-large"""
												else:
																		lowerCamelCase__         =  """dit-base-finetuned-rvlcdip""" if """dit-b""" in checkpoint_url else """dit-large-finetuned-rvlcdip"""
												image_processor.push_to_hub(
												    repo_path_or_name=Path(__lowerCAmelCase   ,    __lowerCAmelCase						)   ,    organization="""nielsr"""   ,    commit_message="""Add image processor"""   ,    use_temp_dir=__lowerCAmelCase   ,    )
												model.push_to_hub(
												    repo_path_or_name=Path(__lowerCAmelCase   ,    __lowerCAmelCase						)   ,    organization="""nielsr"""   ,    commit_message="""Add model"""   ,    use_temp_dir=__lowerCAmelCase   ,    )


if __name__ == "__main__":
							UpperCamelCase    :      Dict  			=		argparse.ArgumentParser()

							parser.add_argument(
							    '--checkpoint_url',
							    default='https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth',
							    type=str,
							    help='URL to the original PyTorch checkpoint (.pth file).',
							)
							parser.add_argument(
							    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
							)
							parser.add_argument(
							    '--push_to_hub',
							    action='store_true',
							)
							UpperCamelCase    :      Optional[int]  			=		parser.parse_args()
							convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)









'''simple docstring'''







UpperCamelCase    :      Tuple  			=		[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_00_00)]
def 						A__			(				__lowerCAmelCase		:			int						):
						lowerCamelCase__         =  0
						while number:
												# Increased Speed Slightly by checking every 5 digits together.
												sum_of_digits_squared += DIGITS_SQUARED[number % 10_0000]
												number //= 10_0000

						return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
UpperCamelCase    :      list[bool | None]  			=		[None] * 10_00_00_00
UpperCamelCase    :      Tuple  			=		True
UpperCamelCase    :      Optional[int]  			=		False
def 						A__			(				__lowerCAmelCase		:			int						):

						if CHAINS[number - 1] is not None:
												return CHAINS[number - 1]  # type: ignore

						lowerCamelCase__         =  chain(next_number(__lowerCAmelCase						)						)
						lowerCamelCase__         =  number_chain

						while number < 1000_0000:
												lowerCamelCase__         =  number_chain
												number *= 10

						return number_chain
def 						A__			(				__lowerCAmelCase		:			int = 1000_0000						):
						for i in range(1   ,    __lowerCAmelCase						):
												if CHAINS[i] is None:
																		chain(i + 1						)

						return CHAINS[:number].count(__lowerCAmelCase						)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(F'{solution() = }')

