


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




					'''simple docstring'''


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

					return image




def        UpperCAmelCase__	(lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_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        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    dct.pop(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    val




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


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

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




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


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

					__SCREAMING_SNAKE_CASE						       =    BlipaConfig(vision_config=lowerCAmelCase_  ,						text_config=lowerCAmelCase_       )

					return config, image_size




@torch.no_grad()
def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_=None  ,						lowerCAmelCase_=False       ):




					'''simple docstring'''


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

					__SCREAMING_SNAKE_CASE						       =    BlipaForConditionalGeneration(lowerCAmelCase_       ).eval()

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

					__SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE						       =    model_name_to_original[model_name]

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

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

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

					# read in qv biases
					read_in_q_v_bias(lowerCAmelCase_  ,						lowerCAmelCase_       )

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

					__SCREAMING_SNAKE_CASE						       =    load_demo_image()
					__SCREAMING_SNAKE_CASE						       =    vis_processors["eval"](lowerCAmelCase_       ).unsqueeze(0       ).to(lowerCAmelCase_       )
					__SCREAMING_SNAKE_CASE						       =    tokenizer(["\n"]  ,						return_tensors="pt"       ).input_ids.to(lowerCAmelCase_       )

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

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

					original_model.to(lowerCAmelCase_       )
					hf_model.to(lowerCAmelCase_       )
					with torch.no_grad():
										if "opt" in model_name:
															__SCREAMING_SNAKE_CASE						       =    original_model({"image": original_pixel_values, "text_input": [""]}       ).logits
															__SCREAMING_SNAKE_CASE						       =    hf_model(lowerCAmelCase_  ,						lowerCAmelCase_       ).logits
										else:
															__SCREAMING_SNAKE_CASE						       =    original_model(
															    {"image": original_pixel_values, "text_input": ["\n"], "text_output": ["\n"]}       ).logits
															__SCREAMING_SNAKE_CASE						       =    input_ids.masked_fill(input_ids == tokenizer.pad_token_id  ,						-100       )
															__SCREAMING_SNAKE_CASE						       =    hf_model(lowerCAmelCase_  ,						lowerCAmelCase_  ,						labels=lowerCAmelCase_       ).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						       =    torch.tensor(
										    [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]]  ,						device=lowerCAmelCase_       )
										assert torch.allclose(logits[0, :3, :3]  ,						lowerCAmelCase_  ,						atol=1E-4       )
					elif model_name == "blip2-flan-t5-xl-coco":
										__SCREAMING_SNAKE_CASE						       =    torch.tensor(
										    [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]]  ,						device=lowerCAmelCase_       )
					else:
										# cast to same type
										__SCREAMING_SNAKE_CASE						       =    logits.dtype
										assert torch.allclose(original_logits.to(lowerCAmelCase_       )  ,						lowerCAmelCase_  ,						atol=1E-2       )
					print("Looks ok!"       )

					print("Generating a caption..."       )
					__SCREAMING_SNAKE_CASE						       =    ""
					__SCREAMING_SNAKE_CASE						       =    tokenizer(lowerCAmelCase_  ,						return_tensors="pt"       ).input_ids.to(lowerCAmelCase_       )

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

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

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


if __name__ == "__main__":
		a__    :							Optional[Any]            =					argparse.ArgumentParser()
		a__    :							Dict            =					[
		    '''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''',
		)

		a__    :							Any            =					parser.parse_args()

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




"""simple docstring"""







from __future__ import annotations




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					print(f"""Vertex\tShortest Distance from vertex {src}"""       )
					for i, d in enumerate(lowerCAmelCase_       ):
										print(f"""{i}\t\t{d}"""       )




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					for j in range(lowerCAmelCase_       ):
										__SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE						       =    (graph[j][k] for k in ["src", "dst", "weight"])
										if distance[u] != float("inf"       ) and distance[u] + w < distance[v]:
															return True
					return False




def        UpperCAmelCase__	(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       ):




					'''simple docstring'''


					__SCREAMING_SNAKE_CASE						       =    [float("inf"       )] * vertex_count
					__SCREAMING_SNAKE_CASE						       =    0.0

					for _ in range(vertex_count - 1       ):
										for j in range(lowerCAmelCase_       ):
															__SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE       ,  __SCREAMING_SNAKE_CASE						       =    (graph[j][k] for k in ["src", "dst", "weight"])

															if distance[u] != float("inf"       ) and distance[u] + w < distance[v]:
																				__SCREAMING_SNAKE_CASE						       =    distance[u] + w

					__SCREAMING_SNAKE_CASE						       =    check_negative_cycle(lowerCAmelCase_  ,						lowerCAmelCase_  ,						lowerCAmelCase_       )
					if negative_cycle_exists:
										raise Exception("Negative cycle found"       )

					return distance


if __name__ == "__main__":
		import doctest

		doctest.testmod()

		a__    :							Union[str, Any]            =					int(input('''Enter number of vertices: ''').strip())
		a__    :							Any            =					int(input('''Enter number of edges: ''').strip())

		a__    :							list[dict[str, int]]            =					[{} for _ in range(E)]

		for i in range(E):
				print('''Edge ''', i + 1)
				a__      ,					a__      ,					a__    :							str            =					(
				    int(x)
				    for x in input('''Enter source, destination, weight: ''').strip().split(''' ''')
				)
				a__    :							str            =					{'''src''': src, '''dst''': dest, '''weight''': weight}

		a__    :							str            =					int(input('''\nEnter shortest path source:''').strip())
		a__    :							List[Any]            =					bellman_ford(graph, V, E, source)
		print_distance(shortest_distance, 0)
