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 	_a						(   )    ->    List[str]:







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

   return image



def 	_a						(   UpperCAmelCase					)    ->    str:







   """simple docstring"""
   lowerCamelCase__       :						str        =							[]
   # 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 	_a						(   UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase					)    ->    List[Any]:







   """simple docstring"""
   lowerCamelCase__       :						str        =							dct.pop(lowerCamelCase__					)
   lowerCamelCase__       :						str        =							val



def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase					)    ->    Dict:







   """simple docstring"""




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

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



def 	_a						(   UpperCAmelCase					)    ->    Union[str, Any]:







   """simple docstring"""
   lowerCamelCase__       :						List[Any]        =							364 if '''coco''' in model_name else 224
   lowerCamelCase__       :						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:
      lowerCamelCase__       :						int        =							TaConfig.from_pretrained('''google/flan-t5-xl'''      ,  dense_act_fn='''gelu'''      ,  bos_token_id=1					).to_dict()
   elif "t5-xxl" in model_name:
      lowerCamelCase__       :						str        =							TaConfig.from_pretrained('''google/flan-t5-xxl'''      ,  dense_act_fn='''gelu'''      ,  bos_token_id=1					).to_dict()
   elif "vicuna-7b" in model_name:
      lowerCamelCase__       :						Any        =							LlamaConfig.from_pretrained('''decapoda-research/llama-7b-hf'''      ,  vocab_size=32001					).to_dict()
   elif "vicuna-13b" in model_name:
      lowerCamelCase__       :						Union[str, Any]        =							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
   lowerCamelCase__       :						Optional[Any]        =							InstructBlipQFormerConfig(vocab_size=30523					).to_dict()
   lowerCamelCase__       :						Any        =							InstructBlipConfig(vision_config=lowerCamelCase__      ,  text_config=lowerCamelCase__      ,  qformer_config=lowerCamelCase__					)

   return config, image_size



@torch.no_grad()
def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase=None      ,  UpperCAmelCase=False					)    ->    int:







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

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

   lowerCamelCase__       ,							lowerCamelCase__       :						Any        =							get_blipa_config(lowerCamelCase__					)
   lowerCamelCase__       :						Optional[int]        =							InstructBlipForConditionalGeneration(lowerCamelCase__					).eval()

   lowerCamelCase__       :						Optional[int]        =							{
       '''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'''),
   }

   lowerCamelCase__       ,							lowerCamelCase__       :						Optional[int]        =							model_name_to_original[model_name]

   # load original model
   print('''Loading original model...'''					)
   lowerCamelCase__       :						Any        =							'''cuda:1''' if torch.cuda.is_available() else '''cpu'''
   lowerCamelCase__       :						int        =							'''cuda:2''' if torch.cuda.is_available() else '''cpu'''
   lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__       :						Any        =							load_model_and_preprocess(
       name=lowerCamelCase__      ,  model_type=lowerCamelCase__      ,  is_eval=lowerCamelCase__      ,  device=lowerCamelCase__					)
   original_model.eval()
   print('''Done!'''					)

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

   lowerCamelCase__       :						List[str]        =							load_demo_image()
   lowerCamelCase__       :						List[Any]        =							'''What is unusual about this image?'''

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

   # make sure processor creates exact same pixel values
   lowerCamelCase__       :						Union[str, Any]        =							vis_processors['''eval'''](lowerCamelCase__					).unsqueeze(0					).to(lowerCamelCase__					)
   lowerCamelCase__       :						Optional[Any]        =							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:
         lowerCamelCase__       :						Optional[int]        =							original_model({'''image''': original_pixel_values, '''text_input''': [prompt]}					).logits
         lowerCamelCase__       :						Optional[Any]        =							hf_model(**lowerCamelCase__					).logits
      else:
         lowerCamelCase__       :						List[Any]        =							original_model(
             {'''image''': original_pixel_values, '''text_input''': [prompt], '''text_output''': ['''\n''']}					).logits
         lowerCamelCase__       :						Union[str, Any]        =							tokenizer('''\n'''      ,  return_tensors='''pt'''					).input_ids.to(lowerCamelCase__					)
         lowerCamelCase__       :						Any        =							label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id      ,  -100					)
         lowerCamelCase__       :						str        =							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
   lowerCamelCase__       :						Optional[int]        =							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...'''					)
   lowerCamelCase__       :						List[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...'''					)
   lowerCamelCase__       :						int        =							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?
      lowerCamelCase__       :						Optional[int]        =							2
   print('''Original generation:'''      ,  lowerCamelCase__					)
   lowerCamelCase__       :						int        =							processor.batch_decode(lowerCamelCase__      ,  skip_special_tokens=lowerCamelCase__					)
   lowerCamelCase__       :						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__":
       _A :   Dict  			=  argparse.ArgumentParser()
       _A :   Tuple  			=  [
           "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',
       )

       _A :   int  			=  parser.parse_args()

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










import pprint

import requests

_A :   Any  			=  'https://zenquotes.io/api'



def 	_a						(   )    ->    list:







   """simple docstring"""
   return requests.get(API_ENDPOINT_URL + '''/today'''					).json()



def 	_a						(   )    ->    list:







   """simple docstring"""
   return requests.get(API_ENDPOINT_URL + '''/random'''					).json()


if __name__ == "__main__":
       _A :   Optional[Any]  			=  random_quotes()
       pprint.pprint(response)



