



"""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						(		):


						'''simple docstring'''






						snake_case_   : Dict						=			"""https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"""
						snake_case_   : Optional[int]						=			Image.open(requests.get(__UpperCamelCase					, stream=__UpperCamelCase    ).raw    ).convert("""RGB"""    )

						return image
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Any    ):


						'''simple docstring'''






						snake_case_   : Optional[int]						=			[]
						# 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      :			Any					, __UpperCamelCase      :			str					, __UpperCamelCase      :			str    ):


						'''simple docstring'''






						snake_case_   : str						=			dct.pop(__UpperCamelCase    )
						snake_case_   : Optional[int]						=			val
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[str]					, __UpperCamelCase      :			str    ):


						'''simple docstring'''






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

												# next, set bias in the state dict
												snake_case_   : Any						=			torch.cat((q_bias, torch.zeros_like(__UpperCamelCase					, requires_grad=__UpperCamelCase    ), v_bias)    )
												snake_case_   : Optional[Any]						=			qkv_bias
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Union[str, Any]					, __UpperCamelCase      :			List[Any]    ):


						'''simple docstring'''






						snake_case_   : Optional[Any]						=			3_6_4 if """coco""" in model_name else 2_2_4
						snake_case_   : List[Any]						=			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_   : str						=			OPTConfig.from_pretrained("""facebook/opt-2.7b"""					, eos_token_id=__UpperCamelCase    ).to_dict()
						elif "opt-6.7b" in model_name:
												snake_case_   : str						=			OPTConfig.from_pretrained("""facebook/opt-6.7b"""					, eos_token_id=__UpperCamelCase    ).to_dict()
						elif "t5-xl" in model_name:
												snake_case_   : Optional[Any]						=			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_   : Any						=			TaConfig.from_pretrained("""google/flan-t5-xxl"""					, dense_act_fn="""gelu"""					, bos_token_id=1    ).to_dict()

						snake_case_   : Tuple						=			BlipaConfig(vision_config=__UpperCamelCase					, text_config=__UpperCamelCase    )

						return config, image_size
@torch.no_grad()
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Dict					, __UpperCamelCase      :			Optional[int]=None					, __UpperCamelCase      :			str=False    ):


						'''simple docstring'''






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

						snake_case_   : Tuple						=			BlipaForConditionalGeneration(__UpperCamelCase    ).eval()

						snake_case_   : Any						=			{
						    """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_   : List[str]						=			model_name_to_original[model_name]

						# load original model
						print("""Loading original model..."""    )
						snake_case_   : Optional[Any]						=			"""cuda""" if torch.cuda.is_available() else """cpu"""
						snake_case_			,		snake_case_			,		snake_case_   : List[Any]						=			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_   : Any						=			original_model.state_dict()
						snake_case_   : List[str]						=			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_   : Any						=			state_dict.pop(__UpperCamelCase    )
												if key.startswith("""Qformer.bert"""    ):
																		snake_case_   : Any						=			key.replace("""Qformer.bert"""					, """qformer"""    )
												if "attention.self" in key:
																		snake_case_   : List[Any]						=			key.replace("""self"""					, """attention"""    )
												if "opt_proj" in key:
																		snake_case_   : str						=			key.replace("""opt_proj"""					, """language_projection"""    )
												if "t5_proj" in key:
																		snake_case_   : Tuple						=			key.replace("""t5_proj"""					, """language_projection"""    )
												if key.startswith("""opt"""    ):
																		snake_case_   : Dict						=			key.replace("""opt"""					, """language"""    )
												if key.startswith("""t5"""    ):
																		snake_case_   : Any						=			key.replace("""t5"""					, """language"""    )
												snake_case_   : Optional[int]						=			val

						# read in qv biases
						read_in_q_v_bias(__UpperCamelCase					, __UpperCamelCase    )

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

						snake_case_   : List[str]						=			load_demo_image()
						snake_case_   : Any						=			vis_processors["""eval"""](__UpperCamelCase    ).unsqueeze(0    ).to(__UpperCamelCase    )
						snake_case_   : Dict						=			tokenizer(["""\n"""]					, return_tensors="""pt"""    ).input_ids.to(__UpperCamelCase    )

						# create processor
						snake_case_   : int						=			BlipImageProcessor(
						    size={"""height""": image_size, """width""": image_size}					, image_mean=__UpperCamelCase					, image_std=__UpperCamelCase    )
						snake_case_   : List[str]						=			BlipaProcessor(image_processor=__UpperCamelCase					, tokenizer=__UpperCamelCase    )
						snake_case_   : List[Any]						=			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_   : List[Any]						=			original_model({"""image""": original_pixel_values, """text_input""": [""""""]}    ).logits
																		snake_case_   : Any						=			hf_model(__UpperCamelCase					, __UpperCamelCase    ).logits
												else:
																		snake_case_   : Tuple						=			original_model(
																		    {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]}    ).logits
																		snake_case_   : List[Any]						=			input_ids.masked_fill(input_ids == tokenizer.pad_token_id					, -1_0_0    )
																		snake_case_   : int						=			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_   : Optional[Any]						=			torch.tensor(
												    [[-41.5_850, -4.4_440, -8.9_922], [-47.4_322, -5.9_143, -1.7_340]]					, device=__UpperCamelCase    )
												assert torch.allclose(logits[0, :3, :3]					, __UpperCamelCase					, atol=1E-4    )
						elif model_name == "blip2-flan-t5-xl-coco":
												snake_case_   : Any						=			torch.tensor(
												    [[-57.0_109, -9.8_967, -12.6_280], [-68.6_578, -12.7_191, -10.5_065]]					, device=__UpperCamelCase    )
						else:
												# cast to same type
												snake_case_   : List[Any]						=			logits.dtype
												assert torch.allclose(original_logits.to(__UpperCamelCase    )					, __UpperCamelCase					, atol=1E-2    )
						print("""Looks ok!"""    )

						print("""Generating a caption..."""    )
						snake_case_   : Optional[int]						=			""""""
						snake_case_   : int						=			tokenizer(__UpperCamelCase					, return_tensors="""pt"""    ).input_ids.to(__UpperCamelCase    )

						snake_case_   : Any						=			original_model.generate({"""image""": original_pixel_values}    )
						snake_case_   : Optional[int]						=			hf_model.generate(
						    __UpperCamelCase					, __UpperCamelCase					, do_sample=__UpperCamelCase					, num_beams=5					, max_length=3_0					, min_length=1					, top_p=0.9					, repetition_penalty=1.0					, length_penalty=1.0					, temperature=1					, )
						print("""Original generation:"""					, __UpperCamelCase    )
						snake_case_   : Optional[int]						=			input_ids.shape[1]
						snake_case_   : Union[str, Any]						=			processor.batch_decode(outputs[:, prompt_length:]					, skip_special_tokens=__UpperCamelCase    )
						snake_case_   : Union[str, Any]						=			[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__":
					__lowerCAmelCase       :					List[str]      					=					argparse.ArgumentParser()
					__lowerCAmelCase       :					Optional[Any]      					=					[
					    '''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''',
					)

					__lowerCAmelCase       :					Any      					=					parser.parse_args()

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






"""simple docstring"""





def 	__lowerCAmelCase						(		__UpperCamelCase      :			str    ):


						'''simple docstring'''






						return " ".join(input_str.split()[::-1]    )


if __name__ == "__main__":
					import doctest

					doctest.testmod()

