

import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD





def  __lowerCamelCase     (			):







							'''simple docstring'''






							snake_case_          =   'https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'
							snake_case_          =   Image.open(requests.get(UpperCamelCase__       ,							stream=UpperCamelCase__				).raw				).convert('RGB'				)

							return image





def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   []
							# fmt: off

							# vision encoder
							rename_keys.append(('visual_encoder.cls_token', 'vision_model.embeddings.class_embedding')				)
							rename_keys.append(('visual_encoder.pos_embed', 'vision_model.embeddings.position_embedding')				)
							rename_keys.append(('visual_encoder.patch_embed.proj.weight', 'vision_model.embeddings.patch_embedding.weight')				)
							rename_keys.append(('visual_encoder.patch_embed.proj.bias', 'vision_model.embeddings.patch_embedding.bias')				)
							rename_keys.append(('ln_vision.weight', 'vision_model.post_layernorm.weight')				)
							rename_keys.append(('ln_vision.bias', 'vision_model.post_layernorm.bias')				)

							for i in range(config.vision_config.num_hidden_layers				):
														rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.weight''', F'''vision_model.encoder.layers.{i}.layer_norm1.weight''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.bias''', F'''vision_model.encoder.layers.{i}.layer_norm1.bias''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.weight''', F'''vision_model.encoder.layers.{i}.layer_norm2.weight''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.bias''', F'''vision_model.encoder.layers.{i}.layer_norm2.bias''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.attn.qkv.weight''', F'''vision_model.encoder.layers.{i}.self_attn.qkv.weight''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.weight''', F'''vision_model.encoder.layers.{i}.self_attn.projection.weight''',)				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.bias''', F'''vision_model.encoder.layers.{i}.self_attn.projection.bias''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc1.weight''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc1.bias''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc2.weight''')				)
														rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc2.bias''')				)

							# QFormer
							rename_keys.append(('Qformer.bert.embeddings.LayerNorm.weight', 'qformer.layernorm.weight')				)
							rename_keys.append(('Qformer.bert.embeddings.LayerNorm.bias', 'qformer.layernorm.bias')				)

							# fmt: on
							return rename_keys





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   dct.pop(UpperCamelCase__				)
							snake_case_          =   val





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							for i in range(config.vision_config.num_hidden_layers				):
														# read in original q and v biases
														snake_case_          =   state_dict.pop(F'''visual_encoder.blocks.{i}.attn.q_bias'''				)
														snake_case_          =   state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''				)

														# next, set bias in the state dict
														snake_case_          =   torch.cat((q_bias, torch.zeros_like(UpperCamelCase__       ,							requires_grad=UpperCamelCase__				), v_bias)				)
														snake_case_          =   qkv_bias





def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   364 if 'coco' in model_name else 224
							snake_case_          =   BlipaVisionConfig(image_size=UpperCamelCase__				).to_dict()

							# make sure the models have proper bos_token_id and eos_token_id set (important for generation)
							# seems like flan-T5 models don't have bos_token_id properly set?
							if "opt-2.7b" in model_name:
														snake_case_          =   OPTConfig.from_pretrained('facebook/opt-2.7b'       ,							eos_token_id=UpperCamelCase__				).to_dict()
							elif "opt-6.7b" in model_name:
														snake_case_          =   OPTConfig.from_pretrained('facebook/opt-6.7b'       ,							eos_token_id=UpperCamelCase__				).to_dict()
							elif "t5-xl" in model_name:
														snake_case_          =   TaConfig.from_pretrained('google/flan-t5-xl'       ,							dense_act_fn='gelu'       ,							bos_token_id=1				).to_dict()
							elif "t5-xxl" in model_name:
														snake_case_          =   TaConfig.from_pretrained('google/flan-t5-xxl'       ,							dense_act_fn='gelu'       ,							bos_token_id=1				).to_dict()

							snake_case_          =   BlipaConfig(vision_config=UpperCamelCase__       ,							text_config=UpperCamelCase__				)

							return config, image_size





@torch.no_grad()
def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__=None       ,							UpperCamelCase__=False				):







							'''simple docstring'''






							snake_case_          =   (
							    AutoTokenizer.from_pretrained('facebook/opt-2.7b'				)
							    if 'opt' in model_name
							    else AutoTokenizer.from_pretrained('google/flan-t5-xl'				)
							)
							snake_case_          =   tokenizer('\n'       ,							add_special_tokens=UpperCamelCase__				).input_ids[0]
							snake_case_    ,   snake_case_          =   get_blipa_config(UpperCamelCase__       ,							eos_token_id=UpperCamelCase__				)

							snake_case_          =   BlipaForConditionalGeneration(UpperCamelCase__				).eval()

							snake_case_          =   {
							    'blip2-opt-2.7b': ('blip2_opt', 'pretrain_opt2.7b'),
							    'blip2-opt-6.7b': ('blip2_opt', 'pretrain_opt6.7b'),
							    'blip2-opt-2.7b-coco': ('blip2_opt', 'caption_coco_opt2.7b'),
							    'blip2-opt-6.7b-coco': ('blip2_opt', 'caption_coco_opt6.7b'),
							    'blip2-flan-t5-xl': ('blip2_t5', 'pretrain_flant5xl'),
							    'blip2-flan-t5-xl-coco': ('blip2_t5', 'caption_coco_flant5xl'),
							    'blip2-flan-t5-xxl': ('blip2_t5', 'pretrain_flant5xxl'),
							}

							snake_case_    ,   snake_case_          =   model_name_to_original[model_name]

							# load original model
							print('Loading original model...'				)
							snake_case_          =   'cuda' if torch.cuda.is_available() else 'cpu'
							snake_case_    ,   snake_case_    ,   snake_case_          =   load_model_and_preprocess(
							    name=UpperCamelCase__       ,							model_type=UpperCamelCase__       ,							is_eval=UpperCamelCase__       ,							device=UpperCamelCase__				)
							original_model.eval()
							print('Done!'				)

							# update state dict keys
							snake_case_          =   original_model.state_dict()
							snake_case_          =   create_rename_keys(UpperCamelCase__				)
							for src, dest in rename_keys:
														rename_key(UpperCamelCase__       ,							UpperCamelCase__       ,							UpperCamelCase__				)

							# some keys can be renamed efficiently
							for key, val in state_dict.copy().items():
														snake_case_          =   state_dict.pop(UpperCamelCase__				)
														if key.startswith('Qformer.bert'				):
																					snake_case_          =   key.replace('Qformer.bert'       ,							'qformer'				)
														if "attention.self" in key:
																					snake_case_          =   key.replace('self'       ,							'attention'				)
														if "opt_proj" in key:
																					snake_case_          =   key.replace('opt_proj'       ,							'language_projection'				)
														if "t5_proj" in key:
																					snake_case_          =   key.replace('t5_proj'       ,							'language_projection'				)
														if key.startswith('opt'				):
																					snake_case_          =   key.replace('opt'       ,							'language'				)
														if key.startswith('t5'				):
																					snake_case_          =   key.replace('t5'       ,							'language'				)
														snake_case_          =   val

							# read in qv biases
							read_in_q_v_bias(UpperCamelCase__       ,							UpperCamelCase__				)

							snake_case_    ,   snake_case_          =   hf_model.load_state_dict(UpperCamelCase__       ,							strict=UpperCamelCase__				)
							assert len(UpperCamelCase__				) == 0
							assert unexpected_keys == ["qformer.embeddings.position_ids"]

							snake_case_          =   load_demo_image()
							snake_case_          =   vis_processors['eval'](UpperCamelCase__				).unsqueeze(0				).to(UpperCamelCase__				)
							snake_case_          =   tokenizer(['\n']       ,							return_tensors='pt'				).input_ids.to(UpperCamelCase__				)

							# create processor
							snake_case_          =   BlipImageProcessor(
							    size={'height': image_size, 'width': image_size}       ,							image_mean=UpperCamelCase__       ,							image_std=UpperCamelCase__				)
							snake_case_          =   BlipaProcessor(image_processor=UpperCamelCase__       ,							tokenizer=UpperCamelCase__				)
							snake_case_          =   processor(images=UpperCamelCase__       ,							return_tensors='pt'				).pixel_values.to(UpperCamelCase__				)

							# make sure processor creates exact same pixel values
							assert torch.allclose(UpperCamelCase__       ,							UpperCamelCase__				)

							original_model.to(UpperCamelCase__				)
							hf_model.to(UpperCamelCase__				)
							with torch.no_grad():
														if "opt" in model_name:
																					snake_case_          =   original_model({'image': original_pixel_values, 'text_input': ['']}				).logits
																					snake_case_          =   hf_model(UpperCamelCase__       ,							UpperCamelCase__				).logits
														else:
																					snake_case_          =   original_model(
																					    {'image': original_pixel_values, 'text_input': ['\n'], 'text_output': ['\n']}				).logits
																					snake_case_          =   input_ids.masked_fill(input_ids == tokenizer.pad_token_id       ,							-100				)
																					snake_case_          =   hf_model(UpperCamelCase__       ,							UpperCamelCase__       ,							labels=UpperCamelCase__				).logits

							assert original_logits.shape == logits.shape
							print('First values of original logits:'       ,							original_logits[0, :3, :3]				)
							print('First values of HF logits:'       ,							logits[0, :3, :3]				)

							# assert values
							if model_name == "blip2-flan-t5-xl":
														snake_case_          =   torch.tensor(
														    [[-41.58_50, -4.44_40, -8.99_22], [-47.43_22, -5.91_43, -1.73_40]]       ,							device=UpperCamelCase__				)
														assert torch.allclose(logits[0, :3, :3]       ,							UpperCamelCase__       ,							atol=1E-4				)
							elif model_name == "blip2-flan-t5-xl-coco":
														snake_case_          =   torch.tensor(
														    [[-57.01_09, -9.89_67, -12.62_80], [-68.65_78, -12.71_91, -10.50_65]]       ,							device=UpperCamelCase__				)
							else:
														# cast to same type
														snake_case_          =   logits.dtype
														assert torch.allclose(original_logits.to(UpperCamelCase__				)       ,							UpperCamelCase__       ,							atol=1E-2				)
							print('Looks ok!'				)

							print('Generating a caption...'				)
							snake_case_          =   ''
							snake_case_          =   tokenizer(UpperCamelCase__       ,							return_tensors='pt'				).input_ids.to(UpperCamelCase__				)

							snake_case_          =   original_model.generate({'image': original_pixel_values}				)
							snake_case_          =   hf_model.generate(
							    UpperCamelCase__       ,							UpperCamelCase__       ,							do_sample=UpperCamelCase__       ,							num_beams=5       ,							max_length=30       ,							min_length=1       ,							top_p=0.9       ,							repetition_penalty=1.0       ,							length_penalty=1.0       ,							temperature=1       ,							)
							print('Original generation:'       ,							UpperCamelCase__				)
							snake_case_          =   input_ids.shape[1]
							snake_case_          =   processor.batch_decode(outputs[:, prompt_length:]       ,							skip_special_tokens=UpperCamelCase__				)
							snake_case_          =   [text.strip() for text in output_text]
							print('HF generation:'       ,							UpperCamelCase__				)

							if pytorch_dump_folder_path is not None:
														processor.save_pretrained(UpperCamelCase__				)
														hf_model.save_pretrained(UpperCamelCase__				)

							if push_to_hub:
														processor.push_to_hub(F'''nielsr/{model_name}'''				)
														hf_model.push_to_hub(F'''nielsr/{model_name}'''				)


if __name__ == "__main__":
					_UpperCAmelCase		:       List[str]						    =	argparse.ArgumentParser()
					_UpperCAmelCase		:       str						    =	[
					    """blip2-opt-2.7b""",
					    """blip2-opt-6.7b""",
					    """blip2-opt-2.7b-coco""",
					    """blip2-opt-6.7b-coco""",
					    """blip2-flan-t5-xl""",
					    """blip2-flan-t5-xl-coco""",
					    """blip2-flan-t5-xxl""",
					]
					parser.add_argument(
					    """--model_name""",
					    default="""blip2-opt-2.7b""",
					    choices=choices,
					    type=str,
					    help="""Path to hf config.json of model to convert""",
					)
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument(
					    """--push_to_hub""",
					    action="""store_true""",
					    help="""Whether to push the model and processor to the hub after converting""",
					)

					_UpperCAmelCase		:       Union[str, Any]						    =	parser.parse_args()

					convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







from math import sqrt





def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   0
							for i in range(1       ,							int(sqrt(UpperCamelCase__				) + 1				)				):
														if n % i == 0 and i != sqrt(UpperCamelCase__				):
																					total += i + n // i
														elif i == sqrt(UpperCamelCase__				):
																					total += i
							return total - n





def  __lowerCamelCase     (			UpperCamelCase__ = 10000				):







							'''simple docstring'''






							snake_case_          =   sum(
							    i
							    for i in range(1       ,							UpperCamelCase__				)
							    if sum_of_divisors(sum_of_divisors(UpperCamelCase__				)				) == i and sum_of_divisors(UpperCamelCase__				) != i				)
							return total


if __name__ == "__main__":
					print(solution(int(str(input()).strip())))




