





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_float32 (there's also the fix_lavis branch)
# also note: to convert Vicuna checkpoints, we had to include /home/niels/python_projects/checkpoints/FastChat/vicuna-7b in lavis/configs/models/blip2/blip2_instruct_vicuna7b.yaml
# same for Vicuna-13b
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipImageProcessor,
    InstructBlipConfig,
    InstructBlipForConditionalGeneration,
    InstructBlipProcessor,
    InstructBlipQFormerConfig,
    InstructBlipVisionConfig,
    LlamaConfig,
    LlamaTokenizerFast,
    TaConfig,
    TaTokenizerFast,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD

def   __snake_case    (       )			->    str:
   A_       :					Union[str, Any]        =      "https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"
   A_       :					List[str]        =      Image.open(requests.get(lowerCAmelCase__					,					stream=lowerCAmelCase__						).raw						).convert("RGB"						)

   return image

def   __snake_case    (       _lowerCAmelCase			:			List[Any]						)			->    int:
   A_       :					Dict        =      []
   # 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.embeddings.layernorm.weight")						)
   rename_keys.append(("Qformer.bert.embeddings.LayerNorm.bias", "qformer.embeddings.layernorm.bias")						)

   # fmt: on
   return rename_keys

def   __snake_case    (       _lowerCAmelCase			:			Optional[int]					,					_lowerCAmelCase			:			Optional[Any]					,					_lowerCAmelCase			:			str						)			->    int:
   A_       :					int        =      dct.pop(lowerCAmelCase__						)
   A_       :					Tuple        =      val

def   __snake_case    (       _lowerCAmelCase			:			Union[str, Any]					,					_lowerCAmelCase			:			Union[str, Any]						)			->    Union[str, Any]:
   for i in range(config.vision_config.num_hidden_layers						):
      # read in original q and v biases
      A_       :					List[Any]        =      state_dict.pop(f"visual_encoder.blocks.{i}.attn.q_bias"						)
      A_       :					str        =      state_dict.pop(f"visual_encoder.blocks.{i}.attn.v_bias"						)

      # next, set bias in the state dict
      A_       :					Optional[Any]        =      torch.cat((q_bias, torch.zeros_like(lowerCAmelCase__					,					requires_grad=lowerCAmelCase__						), v_bias)						)
      A_       :					List[str]        =      qkv_bias

def   __snake_case    (       _lowerCAmelCase			:			Any						)			->    int:
   A_       :					Tuple        =      364 if "coco" in model_name else 224
   A_       :					Union[str, Any]        =      InstructBlipVisionConfig(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 "t5-xl" in model_name:
      A_       :					int        =      TaConfig.from_pretrained("google/flan-t5-xl"					,					dense_act_fn="gelu"					,					bos_token_id=1						).to_dict()
   elif "t5-xxl" in model_name:
      A_       :					Optional[int]        =      TaConfig.from_pretrained("google/flan-t5-xxl"					,					dense_act_fn="gelu"					,					bos_token_id=1						).to_dict()
   elif "vicuna-7b" in model_name:
      A_       :					str        =      LlamaConfig.from_pretrained("decapoda-research/llama-7b-hf"					,					vocab_size=32001						).to_dict()
   elif "vicuna-13b" in model_name:
      A_       :					int        =      LlamaConfig.from_pretrained("decapoda-research/llama-13b-hf"					,					vocab_size=32001						).to_dict()
   else:
      raise ValueError("Model name not supported"						)

   # the authors add one special "[DEC]" token to the vocab of Q-Former, hence vocab size = 30522 + 1
   A_       :					Union[str, Any]        =      InstructBlipQFormerConfig(vocab_size=30523						).to_dict()
   A_       :					int        =      InstructBlipConfig(vision_config=lowerCAmelCase__					,					text_config=lowerCAmelCase__					,					qformer_config=lowerCAmelCase__						)

   return config, image_size

@torch.no_grad()
def   __snake_case    (       _lowerCAmelCase			:			Any					,					_lowerCAmelCase			:			int=None					,					_lowerCAmelCase			:			str=False						)			->    Optional[int]:
   A_       :					List[Any]        =      AutoTokenizer.from_pretrained("bert-base-uncased"					,					truncation_side="left"						)
   qformer_tokenizer.add_special_tokens({"bos_token": "[DEC]"}						)

   if "t5" in model_name:
      A_       :					Dict        =      TaTokenizerFast.from_pretrained("google/flan-t5-xl"					,					truncation_side="left"						)
   elif "vicuna" in model_name:
      # the following was used in the original implementation:
      # tokenizer = LlamaTokenizer.from_pretrained("huggyllama/llama-7b", use_fast=False, truncation_side="left")
      # tokenizer.add_special_tokens({"pad_token": "[PAD]"})
      # tokenizer.add_special_tokens({"bos_token": "</s>"})
      # tokenizer.add_special_tokens({"eos_token": "</s>"})
      # tokenizer.add_special_tokens({"unk_token": "</s>"})
      A_       :					int        =      LlamaTokenizerFast.from_pretrained(
          "huggyllama/llama-7b"					,					truncation_side="left"					,					bos_token="</s>"					,					unk_token="</s>"						)
      tokenizer.add_special_tokens({"pad_token": "[PAD]"}						)

   A_       :					str        =      get_blipa_config(lowerCAmelCase__						)
   A_       :					Optional[int]        =      InstructBlipForConditionalGeneration(lowerCAmelCase__						).eval()

   A_       :					Any        =      {
       "instructblip-vicuna-7b": ("blip2_vicuna_instruct", "vicuna7b"),
       "instructblip-vicuna-13b": ("blip2_vicuna_instruct", "vicuna13b"),
       "instructblip-flan-t5-xl": ("blip2_t5_instruct", "flant5xl"),
       "instructblip-flan-t5-xxl": ("blip2_t5_instruct", "flant5xxl"),
   }

   A_       :					Optional[int]        =      model_name_to_original[model_name]

   # load original model
   print("Loading original model..."						)
   A_       :					int        =      "cuda:1" if torch.cuda.is_available() else "cpu"
   A_       :					Dict        =      "cuda:2" if torch.cuda.is_available() else "cpu"
   A_       :					Optional[Any]        =      load_model_and_preprocess(
       name=lowerCAmelCase__					,					model_type=lowerCAmelCase__					,					is_eval=lowerCAmelCase__					,					device=lowerCAmelCase__						)
   original_model.eval()
   print("Done!"						)

   # update state dict keys
   A_       :					Dict        =      original_model.state_dict()
   A_       :					Any        =      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():
      A_       :					Union[str, Any]        =      state_dict.pop(lowerCAmelCase__						)
      if key.startswith("Qformer.bert"						):
         A_       :					Tuple        =      key.replace("Qformer.bert"					,					"qformer"						)
      if "attention.self" in key:
         A_       :					Optional[Any]        =      key.replace("self"					,					"attention"						)
      if "llm_proj" in key:
         A_       :					int        =      key.replace("llm_proj"					,					"language_projection"						)
      if "t5_proj" in key:
         A_       :					Any        =      key.replace("t5_proj"					,					"language_projection"						)
      if key.startswith("llm_model"						):
         A_       :					str        =      key.replace("llm_model"					,					"language_model"						)
      if key.startswith("t5"						):
         A_       :					str        =      key.replace("t5"					,					"language"						)
      A_       :					List[str]        =      val

   # read in qv biases
   read_in_q_v_bias(lowerCAmelCase__					,					lowerCAmelCase__						)

   # note: weights get loaded in torch.float32 by default
   hf_model.load_state_dict(lowerCAmelCase__					,					strict=lowerCAmelCase__						)

   A_       :					str        =      load_demo_image()
   A_       :					Tuple        =      "What is unusual about this image?"

   # create processor
   A_       :					List[Any]        =      BlipImageProcessor(
       size={"height": image_size, "width": image_size}					,					image_mean=lowerCAmelCase__					,					image_std=lowerCAmelCase__						)
   A_       :					Optional[int]        =      InstructBlipProcessor(
       image_processor=lowerCAmelCase__					,					tokenizer=lowerCAmelCase__					,					qformer_tokenizer=lowerCAmelCase__					,					)
   A_       :					str        =      processor(images=lowerCAmelCase__					,					text=lowerCAmelCase__					,					return_tensors="pt"						).to(lowerCAmelCase__						)

   # make sure processor creates exact same pixel values
   A_       :					Tuple        =      vis_processors["eval"](lowerCAmelCase__						).unsqueeze(0						).to(lowerCAmelCase__						)
   A_       :					List[str]        =      inputs.pixel_values
   assert torch.allclose(original_pixel_values.to(pixel_values.device						)					,					lowerCAmelCase__						)

   original_model.to(lowerCAmelCase__						)
   hf_model.to(lowerCAmelCase__						)
   with torch.no_grad():
      if "vicuna" in model_name:
         A_       :					str        =      original_model({"image": original_pixel_values, "text_input": [prompt]}						).logits
         A_       :					Optional[int]        =      hf_model(**lowerCAmelCase__						).logits
      else:
         A_       :					List[str]        =      original_model(
             {"image": original_pixel_values, "text_input": [prompt], "text_output": ["\n"]}						).logits
         A_       :					Optional[Any]        =      tokenizer("\n"					,					return_tensors="pt"						).input_ids.to(lowerCAmelCase__						)
         A_       :					Any        =      label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id					,					-100						)
         A_       :					int        =      hf_model(**lowerCAmelCase__					,					labels=lowerCAmelCase__						).logits

   print("First values of original logits:"					,					original_logits[0, :3, :3]						)
   print("First values of HF logits:"					,					logits[0, :3, :3]						)

   # assert values
   assert original_logits.shape == logits.shape
   A_       :					Optional[Any]        =      1e-4 if "vicuna" in model_name else 1e-5
   assert torch.allclose(original_logits.to(logits.device						)					,					lowerCAmelCase__					,					atol=lowerCAmelCase__						)
   print("Looks ok!"						)

   print("Generating with original model..."						)
   A_       :					Optional[int]        =      original_model.generate({"image": original_pixel_values, "prompt": prompt}					,					num_beams=5						)

   # important: we need to cast the weights of the HF model to the appropriate type
   print("Generating with HF model..."						)
   A_       :					List[str]        =      hf_model.generate(
       **lowerCAmelCase__					,					do_sample=lowerCAmelCase__					,					num_beams=5					,					max_length=256					,					min_length=1					,					top_p=0.9					,					repetition_penalty=1.5					,					length_penalty=1.0					,					temperature=1					,					)
   if "vicuna" in model_name:
      # convert output id 0 to 2 (eos_token_id)
      # TODO add this in the generate method?
      A_       :					Any        =      2
   print("Original generation:"					,					lowerCAmelCase__						)
   A_       :					Tuple        =      processor.batch_decode(lowerCAmelCase__					,					skip_special_tokens=lowerCAmelCase__						)
   A_       :					Any        =      [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"Salesforce/{model_name}"						)
      hf_model.push_to_hub(f"Salesforce/{model_name}"						)


if __name__ == "__main__":
 _lowerCAmelCase				:   List[Any]						       =						argparse.ArgumentParser()
 _lowerCAmelCase				:   Union[str, Any]						       =						[
     '''instructblip-vicuna-7b''',
     '''instructblip-vicuna-13b''',
     '''instructblip-flan-t5-xl''',
     '''instructblip-flan-t5-xxl''',
 ]
 parser.add_argument(
     '''--model_name''',
     default='''instructblip-flan-t5-xl''',
     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				:   Dict						       =						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      lowercase__ (					lowerCAmelCase__   :			int			)    ->			list[int]:



			'''simple docstring'''
			a__  :	Tuple		 =			[True] * limit
			a__  :	Tuple		 =			False
			a__  :	int		 =			False
			a__  :	Tuple		 =			True

			for i in range(3							,			int(limit**0.5 + 1			)							,			2			):
						a__  :	int		 =			i * 2
						while index < limit:
									a__  :	Union[str, Any]		 =			False
									a__  :	int		 =			index + i

			a__  :	str		 =			[2]

			for i in range(3							,			lowerCAmelCase__							,			2			):
						if is_prime[i]:
									primes.append(lowerCAmelCase__			)

			return primes






def      lowercase__ (					lowerCAmelCase__   :			int = 1_0_0_0_0_0_0			)    ->			int:



			'''simple docstring'''
			a__  :	List[Any]		 =			prime_sieve(lowerCAmelCase__			)
			a__  :	int		 =			0
			a__  :	str		 =			0

			for i in range(len(lowerCAmelCase__			)			):
						for j in range(i + length							,			len(lowerCAmelCase__			)			):
									a__  :	List[str]		 =			sum(primes[i:j]			)
									if sol >= ceiling:
												break

									if sol in primes:
												a__  :	Tuple		 =			j - i
												a__  :	Union[str, Any]		 =			sol

			return largest


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