

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

				return image



def 					_lowercase						(   lowerCamelCase__			:		int							):
				_a        =   []
				# 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 					_lowercase						(   lowerCamelCase__			:		int,		lowerCamelCase__			:		Union[str, Any],		lowerCamelCase__			:		List[str]							):
				_a        =   dct.pop(lowercase__							)
				_a        =   val



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

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



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

				_a        =   BlipaConfig(vision_config=lowercase__,		text_config=lowercase__							)

				return config, image_size



@torch.no_grad()
def 					_lowercase						(   lowerCamelCase__			:		Union[str, Any],		lowerCamelCase__			:		str=None,		lowerCamelCase__			:		Tuple=False							):
				_a        =   (
				    AutoTokenizer.from_pretrained("facebook/opt-2.7b"							)
				    if 'opt' in model_name
				    else AutoTokenizer.from_pretrained("google/flan-t5-xl"							)
				)
				_a        =   tokenizer("\n",		add_special_tokens=lowercase__							).input_ids[0]
				_a        =   get_blipa_config(lowercase__,		eos_token_id=lowercase__							)

				_a        =   BlipaForConditionalGeneration(lowercase__							).eval()

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

				_a        =   model_name_to_original[model_name]

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

				# update state dict keys
				_a        =   original_model.state_dict()
				_a        =   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():
								_a        =   state_dict.pop(lowercase__							)
								if key.startswith("Qformer.bert"							):
												_a        =   key.replace("Qformer.bert",		"qformer"							)
								if "attention.self" in key:
												_a        =   key.replace("self",		"attention"							)
								if "opt_proj" in key:
												_a        =   key.replace("opt_proj",		"language_projection"							)
								if "t5_proj" in key:
												_a        =   key.replace("t5_proj",		"language_projection"							)
								if key.startswith("opt"							):
												_a        =   key.replace("opt",		"language"							)
								if key.startswith("t5"							):
												_a        =   key.replace("t5",		"language"							)
								_a        =   val

				# read in qv biases
				read_in_q_v_bias(lowercase__,		lowercase__							)

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

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

				# create processor
				_a        =   BlipImageProcessor(
				    size={"height": image_size, "width": image_size},		image_mean=lowercase__,		image_std=lowercase__							)
				_a        =   BlipaProcessor(image_processor=lowercase__,		tokenizer=lowercase__							)
				_a        =   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:
												_a        =   original_model({"image": original_pixel_values, "text_input": [""]}							).logits
												_a        =   hf_model(lowercase__,		lowercase__							).logits
								else:
												_a        =   original_model(
												    {"image": original_pixel_values, "text_input": ["\n"], "text_output": ["\n"]}							).logits
												_a        =   input_ids.masked_fill(input_ids == tokenizer.pad_token_id,		-100							)
												_a        =   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":
								_a        =   torch.tensor(
								    [[-41.5_850, -4.44_40, -8.99_22], [-47.4_322, -5.91_43, -1.73_40]],		device=lowercase__							)
								assert torch.allclose(logits[0, :3, :3],		lowercase__,		atol=1e-4							)
				elif model_name == "blip2-flan-t5-xl-coco":
								_a        =   torch.tensor(
								    [[-57.0_109, -9.89_67, -12.6_280], [-68.6_578, -12.7_191, -10.5_065]],		device=lowercase__							)
				else:
								# cast to same type
								_a        =   logits.dtype
								assert torch.allclose(original_logits.to(lowercase__							),		lowercase__,		atol=1e-2							)
				print("Looks ok!"							)

				print("Generating a caption..."							)
				_a        =   ''
				_a        =   tokenizer(lowercase__,		return_tensors="pt"							).input_ids.to(lowercase__							)

				_a        =   original_model.generate({"image": original_pixel_values}							)
				_a        =   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__							)
				_a        =   input_ids.shape[1]
				_a        =   processor.batch_decode(outputs[:, prompt_length:],		skip_special_tokens=lowercase__							)
				_a        =   [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	: Optional[Any]       				=							argparse.ArgumentParser()
							__snake_case	: List[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",
							)

							__snake_case	: 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

from fractions import Fraction
from math import gcd, sqrt







def 	_snake_case     (							lowercase__						):
				_lowerCamelCase	:     int       =       int(number**0.5						)
				return number == sq * sq







def 	_snake_case     (							lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						):
				_lowerCamelCase	:     int       =       x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
				_lowerCamelCase	:     int       =       x_den * y_den * z_den
				_lowerCamelCase	:     int       =       gcd(lowercase__				,       lowercase__						)
				top //= hcf
				bottom //= hcf
				return top, bottom







def 	_snake_case     (							lowercase__ = 35						):
				_lowerCamelCase	:     set       =       set()
				_lowerCamelCase	:     int
				_lowerCamelCase	:     Fraction       =       Fraction(0						)
				_lowerCamelCase	:     tuple[int, int]

				for x_num in range(1				,       order + 1						):
								for x_den in range(x_num + 1				,       order + 1						):
												for y_num in range(1				,       order + 1						):
																for y_den in range(y_num + 1				,       order + 1						):
																				# n=1
																				_lowerCamelCase	:     int       =       x_num * y_den + x_den * y_num
																				_lowerCamelCase	:     List[Any]       =       x_den * y_den
																				_lowerCamelCase	:     int       =       gcd(lowercase__				,       lowercase__						)
																				z_num //= hcf
																				z_den //= hcf
																				if 0 < z_num < z_den <= order:
																								_lowerCamelCase	:     Optional[Any]       =       add_three(
																								    lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						)
																								unique_s.add(lowercase__						)

																				# n=2
																				_lowerCamelCase	:     Tuple       =       (
																				    x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
																				)
																				_lowerCamelCase	:     Dict       =       x_den * x_den * y_den * y_den
																				if is_sq(lowercase__						) and is_sq(lowercase__						):
																								_lowerCamelCase	:     Dict       =       int(sqrt(lowercase__						)						)
																								_lowerCamelCase	:     Optional[Any]       =       int(sqrt(lowercase__						)						)
																								_lowerCamelCase	:     List[Any]       =       gcd(lowercase__				,       lowercase__						)
																								z_num //= hcf
																								z_den //= hcf
																								if 0 < z_num < z_den <= order:
																												_lowerCamelCase	:     Union[str, Any]       =       add_three(
																												    lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						)
																												unique_s.add(lowercase__						)

                    # n=-1
																				_lowerCamelCase	:     List[str]       =       x_num * y_num
																				_lowerCamelCase	:     int       =       x_den * y_num + x_num * y_den
																				_lowerCamelCase	:     Dict       =       gcd(lowercase__				,       lowercase__						)
																				z_num //= hcf
																				z_den //= hcf
																				if 0 < z_num < z_den <= order:
																								_lowerCamelCase	:     List[str]       =       add_three(
																								    lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						)
																								unique_s.add(lowercase__						)

																				# n=2
																				_lowerCamelCase	:     Tuple       =       x_num * x_num * y_num * y_num
																				_lowerCamelCase	:     List[str]       =       (
																				    x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
																				)
																				if is_sq(lowercase__						) and is_sq(lowercase__						):
																								_lowerCamelCase	:     Optional[int]       =       int(sqrt(lowercase__						)						)
																								_lowerCamelCase	:     Optional[int]       =       int(sqrt(lowercase__						)						)
																								_lowerCamelCase	:     Dict       =       gcd(lowercase__				,       lowercase__						)
																								z_num //= hcf
																								z_den //= hcf
																								if 0 < z_num < z_den <= order:
																												_lowerCamelCase	:     int       =       add_three(
																												    lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__				,       lowercase__						)
																												unique_s.add(lowercase__						)

				for num, den in unique_s:
								total += Fraction(lowercase__				,       lowercase__						)

				return total.denominator + total.numerator


if __name__ == "__main__":
			print(F"{solution() = }")