



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

						return image







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Dict						):
						lowercase        =							[]
						# 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      SCREAMING_SNAKE_CASE				(				lowercase_    :      str ,  lowercase_    :      List[Any] ,  lowercase_    :      List[Any]						):
						lowercase        =							dct.pop(lowercase_						)
						lowercase        =							val







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      str ,  lowercase_    :      List[str]						):
						for i in range(config.vision_config.num_hidden_layers						):
												# read in original q and v biases
												lowercase        =							state_dict.pop(F"""visual_encoder.blocks.{i}.attn.q_bias"""						)
												lowercase        =							state_dict.pop(F"""visual_encoder.blocks.{i}.attn.v_bias"""						)

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







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

						lowercase        =							BlipaConfig(vision_config=lowercase_ ,  text_config=lowercase_						)

						return config, image_size







@torch.no_grad()
def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Optional[int] ,  lowercase_    :      int=None ,  lowercase_    :      List[str]=False						):
						lowercase        =							(
						    AutoTokenizer.from_pretrained("""facebook/opt-2.7b"""						)
						    if """opt""" in model_name
						    else AutoTokenizer.from_pretrained("""google/flan-t5-xl"""						)
						)
						lowercase        =							tokenizer("""\n""" ,  add_special_tokens=lowercase_						).input_ids[0]
						lowercase     ,   lowercase        =							get_blipa_config(lowercase_ ,  eos_token_id=lowercase_						)

						lowercase        =							BlipaForConditionalGeneration(lowercase_						).eval()

						lowercase        =							{
						    """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"""),
						}

						lowercase     ,   lowercase        =							model_name_to_original[model_name]

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

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

						# read in qv biases
						read_in_q_v_bias(lowercase_ ,  lowercase_						)

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

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

						# create processor
						lowercase        =							BlipImageProcessor(
						    size={"""height""": image_size, """width""": image_size} ,  image_mean=lowercase_ ,  image_std=lowercase_						)
						lowercase        =							BlipaProcessor(image_processor=lowercase_ ,  tokenizer=lowercase_						)
						lowercase        =							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:
																		lowercase        =							original_model({"""image""": original_pixel_values, """text_input""": [""""""]}						).logits
																		lowercase        =							hf_model(lowercase_ ,  lowercase_						).logits
												else:
																		lowercase        =							original_model(
																		    {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]}						).logits
																		lowercase        =							input_ids.masked_fill(input_ids == tokenizer.pad_token_id ,  -100						)
																		lowercase        =							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":
												lowercase        =							torch.tensor(
												    [[-41.5_850, -4.4_440, -8.9_922], [-47.4_322, -5.9_143, -1.7_340]] ,  device=lowercase_						)
												assert torch.allclose(logits[0, :3, :3] ,  lowercase_ ,  atol=1E-4						)
						elif model_name == "blip2-flan-t5-xl-coco":
												lowercase        =							torch.tensor(
												    [[-57.0_109, -9.8_967, -12.6_280], [-68.6_578, -12.7_191, -10.5_065]] ,  device=lowercase_						)
						else:
												# cast to same type
												lowercase        =							logits.dtype
												assert torch.allclose(original_logits.to(lowercase_						) ,  lowercase_ ,  atol=1E-2						)
						print("""Looks ok!"""						)

						print("""Generating a caption..."""						)
						lowercase        =							""""""
						lowercase        =							tokenizer(lowercase_ ,  return_tensors="""pt"""						).input_ids.to(lowercase_						)

						lowercase        =							original_model.generate({"""image""": original_pixel_values}						)
						lowercase        =							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_						)
						lowercase        =							input_ids.shape[1]
						lowercase        =							processor.batch_decode(outputs[:, prompt_length:] ,  skip_special_tokens=lowercase_						)
						lowercase        =							[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__":
						lowercase_      :				Optional[int]   					=    argparse.ArgumentParser()
						lowercase_      :				Tuple   					=    [
						    '''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''',
						)

						lowercase_      :				List[Any]   					=    parser.parse_args()

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







'''simple docstring'''


def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Union[str, Any] ,  lowercase_    :      str						):
						lowercase        =							""""""
						for i in table:
												res += inp[i - 1]
						return res







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      List[Any]						):
						return data[1:] + data[0]







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Tuple ,  lowercase_    :      Dict						):
						lowercase        =							""""""
						for i in range(len(lowercase_						)						):
												if a[i] == b[i]:
																		res += "0"
												else:
																		res += "1"
						return res







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      str ,  lowercase_    :      str						):
						lowercase        =							int("""0b""" + data[0] + data[-1] ,  2						)
						lowercase        =							int("""0b""" + data[1:3] ,  2						)
						return bin(s[row][col]						)[2:]







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Dict ,  lowercase_    :      Tuple ,  lowercase_    :      Tuple ,  lowercase_    :      str ,  lowercase_    :      Any						):
						lowercase        =							message[:4]
						lowercase        =							message[4:]
						lowercase        =							apply_table(lowercase_ ,  lowercase_						)
						lowercase        =							xor(lowercase_ ,  lowercase_						)
						lowercase        =							apply_sbox(lowercase_ ,  temp[:4]						)  # noqa: E741
						lowercase        =							apply_sbox(lowercase_ ,  temp[4:]						)
						lowercase        =							"""0""" * (2 - len(lowercase_						)) + l  # noqa: E741
						lowercase        =							"""0""" * (2 - len(lowercase_						)) + r
						lowercase        =							apply_table(l + r ,  lowercase_						)
						lowercase        =							xor(lowercase_ ,  lowercase_						)
						return temp + right


if __name__ == "__main__":
						lowercase_      :				Tuple   					=    input('''Enter 10 bit key: ''')
						lowercase_      :				Any   					=    input('''Enter 8 bit message: ''')

						lowercase_      :				Dict   					=    [6, 3, 7, 4, 8, 5, 10, 9]
						lowercase_      :				str   					=    [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
						lowercase_      :				List[Any]   					=    [2, 4, 3, 1]
						lowercase_      :				List[str]   					=    [2, 6, 3, 1, 4, 8, 5, 7]
						lowercase_      :				Tuple   					=    [4, 1, 3, 5, 7, 2, 8, 6]
						lowercase_      :				Optional[Any]   					=    [4, 1, 2, 3, 2, 3, 4, 1]
						lowercase_      :				List[str]   					=    [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
						lowercase_      :				List[Any]   					=    [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

						# key generation
						lowercase_      :				Union[str, Any]   					=    apply_table(key, paa_table)
						lowercase_      :				Optional[Any]   					=    temp[:5]
						lowercase_      :				int   					=    temp[5:]
						lowercase_      :				List[str]   					=    left_shift(left)
						lowercase_      :				int   					=    left_shift(right)
						lowercase_      :				Tuple   					=    apply_table(left + right, pa_table)
						lowercase_      :				List[str]   					=    left_shift(left)
						lowercase_      :				Optional[Any]   					=    left_shift(right)
						lowercase_      :				Union[str, Any]   					=    left_shift(left)
						lowercase_      :				Union[str, Any]   					=    left_shift(right)
						lowercase_      :				Optional[int]   					=    apply_table(left + right, pa_table)

						# encryption
						lowercase_      :				int   					=    apply_table(message, IP)
						lowercase_      :				Dict   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Any   					=    temp[4:] + temp[:4]
						lowercase_      :				List[Any]   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Tuple   					=    apply_table(temp, IP_inv)
						print('''Cipher text is:''', CT)

						# decryption
						lowercase_      :				List[str]   					=    apply_table(CT, IP)
						lowercase_      :				Optional[int]   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Optional[Any]   					=    temp[4:] + temp[:4]
						lowercase_      :				Optional[int]   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Optional[Any]   					=    apply_table(temp, IP_inv)
						print('''Plain text after decypting is:''', PT)


