



"""simple docstring"""


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      (   ):
						UpperCAmelCase             = 'https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'
						UpperCAmelCase             = Image.open(requests.get(lowercase_		,	stream=lowercase_						).raw						).convert('RGB'						)

						return image

def  _lowerCAmelCase      (   lowercase_						):
						UpperCAmelCase             = []
						# 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      (   lowercase_		,	lowercase_		,	lowercase_						):
						UpperCAmelCase             = dct.pop(lowercase_						)
						UpperCAmelCase             = val

def  _lowerCAmelCase      (   lowercase_		,	lowercase_						):
						for i in range(config.vision_config.num_hidden_layers						):
												# read in original q and v biases
												UpperCAmelCase             = state_dict.pop(F"""visual_encoder.blocks.{i}.attn.q_bias"""						)
												UpperCAmelCase             = state_dict.pop(F"""visual_encoder.blocks.{i}.attn.v_bias"""						)

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

def  _lowerCAmelCase      (   lowercase_		,	lowercase_						):
						UpperCAmelCase             = 364 if 'coco' in model_name else 224
						UpperCAmelCase             = BlipaVisionConfig(image_size=lowercase_						).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:
												UpperCAmelCase             = OPTConfig.from_pretrained('facebook/opt-2.7b'		,	eos_token_id=lowercase_						).to_dict()
						elif "opt-6.7b" in model_name:
												UpperCAmelCase             = OPTConfig.from_pretrained('facebook/opt-6.7b'		,	eos_token_id=lowercase_						).to_dict()
						elif "t5-xl" in model_name:
												UpperCAmelCase             = TaConfig.from_pretrained('google/flan-t5-xl'		,	dense_act_fn='gelu'		,	bos_token_id=1						).to_dict()
						elif "t5-xxl" in model_name:
												UpperCAmelCase             = TaConfig.from_pretrained('google/flan-t5-xxl'		,	dense_act_fn='gelu'		,	bos_token_id=1						).to_dict()

						UpperCAmelCase             = BlipaConfig(vision_config=lowercase_		,	text_config=lowercase_						)

						return config, image_size

@torch.no_grad()
def  _lowerCAmelCase      (   lowercase_		,	lowercase_=None		,	lowercase_=False						):
						UpperCAmelCase             = (
						    AutoTokenizer.from_pretrained('facebook/opt-2.7b'						)
						    if 'opt' in model_name
						    else AutoTokenizer.from_pretrained('google/flan-t5-xl'						)
						)
						UpperCAmelCase             = tokenizer('\n'		,	add_special_tokens=lowercase_						).input_ids[0]
						UpperCAmelCase      ,    UpperCAmelCase             = get_blipa_config(lowercase_		,	eos_token_id=lowercase_						)

						UpperCAmelCase             = BlipaForConditionalGeneration(lowercase_						).eval()

						UpperCAmelCase             = {
						    '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'),
						}

						UpperCAmelCase      ,    UpperCAmelCase             = model_name_to_original[model_name]

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

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

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

						# read in qv biases
						read_in_q_v_bias(lowercase_		,	lowercase_						)

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

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

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

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

						original_model.to(lowercase_						)
						hf_model.to(lowercase_						)
						with torch.no_grad():
												if "opt" in model_name:
																		UpperCAmelCase             = original_model({'image': original_pixel_values, 'text_input': ['']}						).logits
																		UpperCAmelCase             = hf_model(lowercase_		,	lowercase_						).logits
												else:
																		UpperCAmelCase             = original_model(
																		    {'image': original_pixel_values, 'text_input': ['\n'], 'text_output': ['\n']}						).logits
																		UpperCAmelCase             = input_ids.masked_fill(input_ids == tokenizer.pad_token_id		,	-100						)
																		UpperCAmelCase             = hf_model(lowercase_		,	lowercase_		,	labels=lowercase_						).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":
												UpperCAmelCase             = torch.tensor(
												    [[-4_1.5_8_5_0, -4.4_4_4_0, -8.9_9_2_2], [-4_7.4_3_2_2, -5.9_1_4_3, -1.7_3_4_0]]		,	device=lowercase_						)
												assert torch.allclose(logits[0, :3, :3]		,	lowercase_		,	atol=1e-4						)
						elif model_name == "blip2-flan-t5-xl-coco":
												UpperCAmelCase             = torch.tensor(
												    [[-5_7.0_1_0_9, -9.8_9_6_7, -1_2.6_2_8_0], [-6_8.6_5_7_8, -1_2.7_1_9_1, -1_0.5_0_6_5]]		,	device=lowercase_						)
						else:
												# cast to same type
												UpperCAmelCase             = logits.dtype
												assert torch.allclose(original_logits.to(lowercase_						)		,	lowercase_		,	atol=1e-2						)
						print('Looks ok!'						)

						print('Generating a caption...'						)
						UpperCAmelCase             = ''
						UpperCAmelCase             = tokenizer(lowercase_		,	return_tensors='pt'						).input_ids.to(lowercase_						)

						UpperCAmelCase             = original_model.generate({'image': original_pixel_values}						)
						UpperCAmelCase             = hf_model.generate(
						    lowercase_		,	lowercase_		,	do_sample=lowercase_		,	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:'		,	lowercase_						)
						UpperCAmelCase             = input_ids.shape[1]
						UpperCAmelCase             = processor.batch_decode(outputs[:, prompt_length:]		,	skip_special_tokens=lowercase_						)
						UpperCAmelCase             = [text.strip() for text in output_text]
						print('HF generation:'		,	lowercase_						)

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

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


if __name__ == "__main__":
				snake_case_				     =       argparse.ArgumentParser()
				snake_case_				     =       [
				    """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""",
				)

				snake_case_				     =       parser.parse_args()

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










"""simple docstring"""






from functools import lru_cache






def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__		:		Optional[Any]			=2
			lowerCamelCase__		:		Optional[int]			=set()
			while i * i <= n:
						if n % i:
									i += 1
						else:
									n //= i
									factors.add(__lowerCamelCase	)
			if n > 1:
						factors.add(__lowerCamelCase	)
			return factors






@lru_cache
def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			return len(unique_prime_factors(__lowerCamelCase	)	)






def      snake_case__   (		__lowerCamelCase				:    list	):
			"""simple docstring"""
			return len(set(__lowerCamelCase	)	) in (0, 1)






def      snake_case__   (		__lowerCamelCase				:    int	):
			"""simple docstring"""
			lowerCamelCase__		:		Tuple			=2

			while True:
						# Increment each value of a generated range
						lowerCamelCase__		:		Tuple			=[base + i for i in range(__lowerCamelCase	)]

						# Run elements through out unique_prime_factors function
						# Append our target number to the end.
						lowerCamelCase__		:		Optional[Any]			=[upf_len(__lowerCamelCase	) for x in group]
						checker.append(__lowerCamelCase	)

						# If all numbers in the list are equal, return the group variable.
						if equality(__lowerCamelCase	):
									return group

						# Increment our base variable by 1
						base += 1






def      snake_case__   (		__lowerCamelCase				:    int = 4	):
			"""simple docstring"""
			lowerCamelCase__		:		List[Any]			=run(__lowerCamelCase	)
			return results[0] if len(__lowerCamelCase	) else None


if __name__ == "__main__":
		print(solution())




