






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



  '''simple docstring'''
  _a  :       List[Any]             =	"""https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg"""
  _a  :       List[str]             =	Image.open(requests.get(UpperCamelCase__     ,   stream=UpperCamelCase__				).raw				).convert("""RGB"""				)

  return image

def 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Tuple             =	[]
  # 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 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Dict             =	dct.pop(UpperCamelCase__				)
  _a  :       Union[str, Any]             =	val

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  for i in range(config.vision_config.num_hidden_layers				):
    # read in original q and v biases
    _a  :       int             =	state_dict.pop(F"""visual_encoder.blocks.{i}.attn.q_bias"""				)
    _a  :       int             =	state_dict.pop(F"""visual_encoder.blocks.{i}.attn.v_bias"""				)

    # next, set bias in the state dict
    _a  :       Optional[int]             =	torch.cat((q_bias, torch.zeros_like(UpperCamelCase__     ,   requires_grad=UpperCamelCase__				), v_bias)				)
    _a  :       Optional[int]             =	qkv_bias

def 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Tuple             =	3_6_4 if """coco""" in model_name else 2_2_4
  _a  :       int             =	InstructBlipVisionConfig(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 "t5-xl" in model_name:
    _a  :       Optional[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  :       List[str]             =	TaConfig.from_pretrained("""google/flan-t5-xxl"""     ,   dense_act_fn="""gelu"""     ,   bos_token_id=1				).to_dict()
  elif "vicuna-7b" in model_name:
    _a  :       int             =	LlamaConfig.from_pretrained("""decapoda-research/llama-7b-hf"""     ,   vocab_size=3_2_0_0_1				).to_dict()
  elif "vicuna-13b" in model_name:
    _a  :       Any             =	LlamaConfig.from_pretrained("""decapoda-research/llama-13b-hf"""     ,   vocab_size=3_2_0_0_1				).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  :       List[str]             =	InstructBlipQFormerConfig(vocab_size=3_0_5_2_3				).to_dict()
  _a  :       List[Any]             =	InstructBlipConfig(vision_config=UpperCamelCase__     ,   text_config=UpperCamelCase__     ,   qformer_config=UpperCamelCase__				)

  return config, image_size

@torch.no_grad()
def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__=None     ,   UpperCamelCase__=False				):



  '''simple docstring'''
  _a  :       Optional[Any]             =	AutoTokenizer.from_pretrained("""bert-base-uncased"""     ,   truncation_side="""left"""				)
  qformer_tokenizer.add_special_tokens({"""bos_token""": """[DEC]"""}				)

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

  _a      ,  _a  :       Tuple             =	get_blipa_config(UpperCamelCase__				)
  _a  :       Optional[Any]             =	InstructBlipForConditionalGeneration(UpperCamelCase__				).eval()

  _a  :       List[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      ,  _a  :       Union[str, Any]             =	model_name_to_original[model_name]

  # load original model
  print("""Loading original model..."""				)
  _a  :       Union[str, Any]             =	"""cuda:1""" if torch.cuda.is_available() else """cpu"""
  _a  :       Any             =	"""cuda:2""" if torch.cuda.is_available() else """cpu"""
  _a      ,  _a      ,  _a  :       List[str]             =	load_model_and_preprocess(
      name=UpperCamelCase__     ,   model_type=UpperCamelCase__     ,   is_eval=UpperCamelCase__     ,   device=UpperCamelCase__				)
  original_model.eval()
  print("""Done!"""				)

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

  # read in qv biases
  read_in_q_v_bias(UpperCamelCase__     ,   UpperCamelCase__				)

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

  _a  :       Optional[Any]             =	load_demo_image()
  _a  :       int             =	"""What is unusual about this image?"""

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

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

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

  print("""Generating with original model..."""				)
  _a  :       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  :       Union[str, Any]             =	hf_model.generate(
      **UpperCamelCase__     ,   do_sample=UpperCamelCase__     ,   num_beams=5     ,   max_length=2_5_6     ,   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  :       List[str]             =	2
  print("""Original generation:"""     ,   UpperCamelCase__				)
  _a  :       List[Any]             =	processor.batch_decode(UpperCamelCase__     ,   skip_special_tokens=UpperCamelCase__				)
  _a  :       Optional[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"""Salesforce/{model_name}"""				)
    hf_model.push_to_hub(F"""Salesforce/{model_name}"""				)


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

 _snake_case          =   parser.parse_args()

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









"""simple docstring"""




def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''

  # Check if the input is valid
  if not len(UpperCamelCase__				) == len(UpperCamelCase__				) == 3:
    raise ValueError("""Please enter a valid equation."""				)
  if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
    raise ValueError("""Both a & b of two equations can't be zero."""				)

  # Extract the coefficients
  _a      ,  _a      ,  _a  :       Any             =	equationa
  _a      ,  _a      ,  _a  :       Tuple             =	equationa

  # Calculate the determinants of the matrices
  _a  :       int             =	aa * ba - aa * ba
  _a  :       str             =	ca * ba - ca * ba
  _a  :       str             =	aa * ca - aa * ca

  # Check if the system of linear equations has a solution (using Cramer's rule)
  if determinant == 0:
    if determinant_x == determinant_y == 0:
      raise ValueError("""Infinite solutions. (Consistent system)"""				)
    else:
      raise ValueError("""No solution. (Inconsistent system)"""				)
  else:
    if determinant_x == determinant_y == 0:
      # Trivial solution (Inconsistent system)
      return (0.0, 0.0)
    else:
      _a  :       Dict             =	determinant_x / determinant
      _a  :       str             =	determinant_y / determinant
      # Non-Trivial Solution (Consistent system)
      return (x, y)

