


"""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_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 					lowercase      (    )->				Any:
  '''simple docstring'''







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

  return image


def 					lowercase      (    A_	)->				List[str]:
  '''simple docstring'''







  a						:		Union[str, Any]											=      []
  # 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 					lowercase      (    A_  ,       A_  ,       A_	)->				Optional[int]:
  '''simple docstring'''







  a						:		int											=      dct.pop(A_	)
  a						:		str											=      val


def 					lowercase      (    A_  ,       A_	)->				int:
  '''simple docstring'''







  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						:		Tuple											=      state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''	)

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


def 					lowercase      (    A_	)->				Dict:
  '''simple docstring'''







  a						:		List[str]											=      364 if "coco" in model_name else 224
  a						:		Dict											=      InstructBlipVisionConfig(image_size=A_	).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						:		List[str]											=      TaConfig.from_pretrained("google/flan-t5-xl"  ,       dense_act_fn="gelu"  ,       bos_token_id=1	).to_dict()
  elif "t5-xxl" in model_name:
    a						:		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						:		Tuple											=      LlamaConfig.from_pretrained("decapoda-research/llama-7b-hf"  ,       vocab_size=32_001	).to_dict()
  elif "vicuna-13b" in model_name:
    a						:		Optional[int]											=      LlamaConfig.from_pretrained("decapoda-research/llama-13b-hf"  ,       vocab_size=32_001	).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						:		Dict											=      InstructBlipQFormerConfig(vocab_size=30_523	).to_dict()
  a						:		Optional[int]											=      InstructBlipConfig(vision_config=A_  ,       text_config=A_  ,       qformer_config=A_	)

  return config, image_size


@torch.no_grad()
def 					lowercase      (    A_  ,       A_=None  ,       A_=False	)->				Union[str, Any]:
  '''simple docstring'''







  a						:		Optional[int]											=      AutoTokenizer.from_pretrained("bert-base-uncased"  ,       truncation_side="left"	)
  qformer_tokenizer.add_special_tokens({"bos_token": "[DEC]"}	)

  if "t5" in model_name:
    a						:		int											=      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						:		Union[str, Any]											=      LlamaTokenizerFast.from_pretrained(
        "huggyllama/llama-7b"  ,       truncation_side="left"  ,       bos_token="</s>"  ,       unk_token="</s>"	)
    tokenizer.add_special_tokens({"pad_token": "[PAD]"}	)

  a						:		int											=      get_blipa_config(A_	)
  a						:		Tuple											=      InstructBlipForConditionalGeneration(A_	).eval()

  a						:		Optional[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						:		str											=      "cuda:1" if torch.cuda.is_available() else "cpu"
  a						:		Dict											=      "cuda:2" if torch.cuda.is_available() else "cpu"
  a						:		Tuple											=      load_model_and_preprocess(
      name=A_  ,       model_type=A_  ,       is_eval=A_  ,       device=A_	)
  original_model.eval()
  print("Done!"	)

  # update state dict keys
  a						:		Optional[int]											=      original_model.state_dict()
  a						:		Any											=      create_rename_keys(A_	)
  for src, dest in rename_keys:
    rename_key(A_  ,       A_  ,       A_	)

  # some keys can be renamed efficiently
  for key, val in state_dict.copy().items():
    a						:		Dict											=      state_dict.pop(A_	)
    if key.startswith("Qformer.bert"	):
      a						:		Any											=      key.replace("Qformer.bert"  ,       "qformer"	)
    if "attention.self" in key:
      a						:		Dict											=      key.replace("self"  ,       "attention"	)
    if "llm_proj" in key:
      a						:		Union[str, Any]											=      key.replace("llm_proj"  ,       "language_projection"	)
    if "t5_proj" in key:
      a						:		Union[str, Any]											=      key.replace("t5_proj"  ,       "language_projection"	)
    if key.startswith("llm_model"	):
      a						:		Any											=      key.replace("llm_model"  ,       "language_model"	)
    if key.startswith("t5"	):
      a						:		List[str]											=      key.replace("t5"  ,       "language"	)
    a						:		int											=      val

  # read in qv biases
  read_in_q_v_bias(A_  ,       A_	)

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

  a						:		Tuple											=      load_demo_image()
  a						:		int											=      "What is unusual about this image?"

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

  # make sure processor creates exact same pixel values
  a						:		int											=      vis_processors["eval"](A_	).unsqueeze(0	).to(A_	)
  a						:		Optional[Any]											=      inputs.pixel_values
  assert torch.allclose(original_pixel_values.to(pixel_values.device	)  ,       A_	)

  original_model.to(A_	)
  hf_model.to(A_	)
  with torch.no_grad():
    if "vicuna" in model_name:
      a						:		int											=      original_model({"image": original_pixel_values, "text_input": [prompt]}	).logits
      a						:		Any											=      hf_model(**A_	).logits
    else:
      a						:		int											=      original_model(
          {"image": original_pixel_values, "text_input": [prompt], "text_output": ["\n"]}	).logits
      a						:		Optional[Any]											=      tokenizer("\n"  ,       return_tensors="pt"	).input_ids.to(A_	)
      a						:		str											=      label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id  ,       -100	)
      a						:		List[Any]											=      hf_model(**A_  ,       labels=A_	).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						:		Union[str, Any]											=      1e-4 if "vicuna" in model_name else 1e-5
  assert torch.allclose(original_logits.to(logits.device	)  ,       A_  ,       atol=A_	)
  print("Looks ok!"	)

  print("Generating with original model..."	)
  a						:		Union[str, Any]											=      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						:		Union[str, Any]											=      hf_model.generate(
      **A_  ,       do_sample=A_  ,       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						:		str											=      2
  print("Original generation:"  ,       A_	)
  a						:		List[Any]											=      processor.batch_decode(A_  ,       skip_special_tokens=A_	)
  a						:		List[Any]											=      [text.strip() for text in output_text]
  print("HF generation:"  ,       A_	)

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

  if push_to_hub:
    processor.push_to_hub(F'''Salesforce/{model_name}'''	)
    hf_model.push_to_hub(F'''Salesforce/{model_name}'''	)


if __name__ == "__main__":
 __lowercase    =				argparse.ArgumentParser()
 __lowercase    =				[
     """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""",
 )

 __lowercase    =				parser.parse_args()

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










"""simple docstring"""







from math import ceil, sqrt


def 					lowercase      (    A_ = 1_000_000	)->				int:
  '''simple docstring'''







  a						:		Tuple											=      0

  for outer_width in range(3  ,       (limit // 4) + 2	):
    if outer_width**2 > limit:
      a						:		str											=      max(ceil(sqrt(outer_width**2 - limit	)	)  ,       1	)
    else:
      a						:		Tuple											=      1
    if (outer_width - hole_width_lower_bound) % 2:
      hole_width_lower_bound += 1

    answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

  return answer


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






