





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    A			(					):
						SCREAMING_SNAKE_CASE							:					Dict           =							"""https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"""
						SCREAMING_SNAKE_CASE							:					Optional[int]           =							Image.open(requests.get(__UpperCamelCase	,						stream=__UpperCamelCase		).raw		).convert('''RGB'''		)

						return image
def    A			(					_lowercase		):
						SCREAMING_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    A			(					_lowercase	,						_lowercase	,						_lowercase		):
						SCREAMING_SNAKE_CASE							:					str           =							dct.pop(__UpperCamelCase		)
						SCREAMING_SNAKE_CASE							:					Optional[int]           =							val
def    A			(					_lowercase	,						_lowercase		):






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

												# next, set bias in the state dict
												SCREAMING_SNAKE_CASE							:					Any           =							torch.cat((q_bias, torch.zeros_like(__UpperCamelCase	,						requires_grad=__UpperCamelCase		), v_bias)		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							qkv_bias
def    A			(					_lowercase	,						_lowercase		):
						SCREAMING_SNAKE_CASE							:					Optional[Any]           =							364 if """coco""" in model_name else 224
						SCREAMING_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:
												SCREAMING_SNAKE_CASE							:					str           =							OPTConfig.from_pretrained('''facebook/opt-2.7b'''	,						eos_token_id=__UpperCamelCase		).to_dict()
						elif "opt-6.7b" in model_name:
												SCREAMING_SNAKE_CASE							:					str           =							OPTConfig.from_pretrained('''facebook/opt-6.7b'''	,						eos_token_id=__UpperCamelCase		).to_dict()
						elif "t5-xl" in model_name:
												SCREAMING_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:
												SCREAMING_SNAKE_CASE							:					Any           =							TaConfig.from_pretrained('''google/flan-t5-xxl'''	,						dense_act_fn='''gelu'''	,						bos_token_id=1		).to_dict()

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

						return config, image_size
@torch.no_grad()
def    A			(					_lowercase	,						_lowercase=None	,						_lowercase=False		):
						SCREAMING_SNAKE_CASE							:					Dict           =							(
						    AutoTokenizer.from_pretrained('''facebook/opt-2.7b'''		)
						    if """opt""" in model_name
						    else AutoTokenizer.from_pretrained('''google/flan-t5-xl'''		)
						)
						SCREAMING_SNAKE_CASE							:					Dict           =							tokenizer('''\n'''	,						add_special_tokens=__UpperCamelCase		).input_ids[0]
						SCREAMING_SNAKE_CASE							:					List[str]           =							get_blipa_config(__UpperCamelCase	,						eos_token_id=__UpperCamelCase		)

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

						SCREAMING_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"""),
						}

						SCREAMING_SNAKE_CASE							:					List[str]           =							model_name_to_original[model_name]

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

						# read in qv biases
						read_in_q_v_bias(__UpperCamelCase	,						__UpperCamelCase		)

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

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

						# create processor
						SCREAMING_SNAKE_CASE							:					int           =							BlipImageProcessor(
						    size={'''height''': image_size, '''width''': image_size}	,						image_mean=__UpperCamelCase	,						image_std=__UpperCamelCase		)
						SCREAMING_SNAKE_CASE							:					List[str]           =							BlipaProcessor(image_processor=__UpperCamelCase	,						tokenizer=__UpperCamelCase		)
						SCREAMING_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:
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							original_model({'''image''': original_pixel_values, '''text_input''': ['''''']}		).logits
																		SCREAMING_SNAKE_CASE							:					Any           =							hf_model(__UpperCamelCase	,						__UpperCamelCase		).logits
												else:
																		SCREAMING_SNAKE_CASE							:					Tuple           =							original_model(
																		    {'''image''': original_pixel_values, '''text_input''': ['''\n'''], '''text_output''': ['''\n''']}		).logits
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							input_ids.masked_fill(input_ids == tokenizer.pad_token_id	,						-100		)
																		SCREAMING_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":
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							torch.tensor(
												    [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]]	,						device=__UpperCamelCase		)
												assert torch.allclose(logits[0, :3, :3]	,						__UpperCamelCase	,						atol=1e-4		)
						elif model_name == "blip2-flan-t5-xl-coco":
												SCREAMING_SNAKE_CASE							:					Any           =							torch.tensor(
												    [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]]	,						device=__UpperCamelCase		)
						else:
												# cast to same type
												SCREAMING_SNAKE_CASE							:					List[Any]           =							logits.dtype
												assert torch.allclose(original_logits.to(__UpperCamelCase		)	,						__UpperCamelCase	,						atol=1e-2		)
						print('''Looks ok!'''		)

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

						SCREAMING_SNAKE_CASE							:					Any           =							original_model.generate({'''image''': original_pixel_values}		)
						SCREAMING_SNAKE_CASE							:					Optional[int]           =							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		)
						SCREAMING_SNAKE_CASE							:					Optional[int]           =							input_ids.shape[1]
						SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							processor.batch_decode(outputs[:, prompt_length:]	,						skip_special_tokens=__UpperCamelCase		)
						SCREAMING_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__":
					__UpperCamelCase	: List[str]    		=  argparse.ArgumentParser()
					__UpperCamelCase	: 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',
					)

					__UpperCamelCase	: Any    		=  parser.parse_args()

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






from __future__ import annotations

from typing import Any





class       lowercase__		(     UpperCamelCase_):
						pass






class       lowercase__		:


						def __init__( self			:       Union[str, Any]					,	UpperCamelCase__			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							data
												SCREAMING_SNAKE_CASE							:					Node | None           =							None


						def __iter__( self			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							self
												SCREAMING_SNAKE_CASE							:					Tuple           =							[]
												while node:
																		if node in visited:
																								raise ContainsLoopError
																		visited.append(UpperCamelCase__		)
																		yield node.data
																		SCREAMING_SNAKE_CASE							:					Dict           =							node.next_node



						@property
						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												try:
																		list(self		)
																		return False
												except ContainsLoopError:
																		return True


if __name__ == "__main__":
					__UpperCamelCase	: List[Any]    		=  Node(1)
					__UpperCamelCase	: str    		=  Node(2)
					__UpperCamelCase	: Dict    		=  Node(3)
					__UpperCamelCase	: List[Any]    		=  Node(4)
					print(root_node.has_loop)  # False
					__UpperCamelCase	: int    		=  root_node.next_node
					print(root_node.has_loop)  # True

					__UpperCamelCase	: Union[str, Any]    		=  Node(5)
					__UpperCamelCase	: Union[str, Any]    		=  Node(6)
					__UpperCamelCase	: List[Any]    		=  Node(5)
					__UpperCamelCase	: List[str]    		=  Node(6)
					print(root_node.has_loop)  # False

					__UpperCamelCase	: List[Any]    		=  Node(1)
					print(root_node.has_loop)  # False





