






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		(							):
				A	 =      'https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg'
				A	 =      Image.open(requests.get(UpperCAmelCase,						stream=UpperCAmelCase   ).raw   ).convert('RGB'   )

				return image







def      snake_case		(							UpperCAmelCase	:       int   ):
				A	 =      []
				# 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		(							UpperCAmelCase	:       Dict,						UpperCAmelCase	:       List[str],						UpperCAmelCase	:       Optional[int]   ):
				A	 =      dct.pop(UpperCAmelCase   )
				A	 =      val







def      snake_case		(							UpperCAmelCase	:       List[Any],						UpperCAmelCase	:       Any   ):
				for i in range(config.vision_config.num_hidden_layers   ):
								# read in original q and v biases
								A	 =      state_dict.pop(f'visual_encoder.blocks.{i}.attn.q_bias'   )
								A	 =      state_dict.pop(f'visual_encoder.blocks.{i}.attn.v_bias'   )

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







def      snake_case		(							UpperCAmelCase	:       Optional[int]   ):
				A	 =      3_64 if 'coco' in model_name else 2_24
				A	 =      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	 =      TaConfig.from_pretrained('google/flan-t5-xl',						dense_act_fn='gelu',						bos_token_id=1   ).to_dict()
				elif "t5-xxl" in model_name:
								A	 =      TaConfig.from_pretrained('google/flan-t5-xxl',						dense_act_fn='gelu',						bos_token_id=1   ).to_dict()
				elif "vicuna-7b" in model_name:
								A	 =      LlamaConfig.from_pretrained('decapoda-research/llama-7b-hf',						vocab_size=3_20_01   ).to_dict()
				elif "vicuna-13b" in model_name:
								A	 =      LlamaConfig.from_pretrained('decapoda-research/llama-13b-hf',						vocab_size=3_20_01   ).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	 =      InstructBlipQFormerConfig(vocab_size=3_05_23   ).to_dict()
				A	 =      InstructBlipConfig(vision_config=UpperCAmelCase,						text_config=UpperCAmelCase,						qformer_config=UpperCAmelCase   )

				return config, image_size







@torch.no_grad()
def      snake_case		(							UpperCAmelCase	:       str,						UpperCAmelCase	:       Union[str, Any]=None,						UpperCAmelCase	:       Any=False   ):
				A	 =      AutoTokenizer.from_pretrained('bert-base-uncased',						truncation_side='left'   )
				qformer_tokenizer.add_special_tokens({'bos_token': '[DEC]'}   )

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

				A ,		A	 =      get_blipa_config(UpperCAmelCase   )
				A	 =      InstructBlipForConditionalGeneration(UpperCAmelCase   ).eval()

				A	 =      {
				    '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	 =      model_name_to_original[model_name]

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

				# update state dict keys
				A	 =      original_model.state_dict()
				A	 =      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	 =      state_dict.pop(UpperCAmelCase   )
								if key.startswith('Qformer.bert'   ):
												A	 =      key.replace('Qformer.bert',						'qformer'   )
								if "attention.self" in key:
												A	 =      key.replace('self',						'attention'   )
								if "llm_proj" in key:
												A	 =      key.replace('llm_proj',						'language_projection'   )
								if "t5_proj" in key:
												A	 =      key.replace('t5_proj',						'language_projection'   )
								if key.startswith('llm_model'   ):
												A	 =      key.replace('llm_model',						'language_model'   )
								if key.startswith('t5'   ):
												A	 =      key.replace('t5',						'language'   )
								A	 =      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	 =      load_demo_image()
				A	 =      'What is unusual about this image?'

				# create processor
				A	 =      BlipImageProcessor(
				    size={'height': image_size, 'width': image_size},						image_mean=UpperCAmelCase,						image_std=UpperCAmelCase   )
				A	 =      InstructBlipProcessor(
				    image_processor=UpperCAmelCase,						tokenizer=UpperCAmelCase,						qformer_tokenizer=UpperCAmelCase,						)
				A	 =      processor(images=UpperCAmelCase,						text=UpperCAmelCase,						return_tensors='pt'   ).to(UpperCAmelCase   )

				# make sure processor creates exact same pixel values
				A	 =      vis_processors['eval'](UpperCAmelCase   ).unsqueeze(0   ).to(UpperCAmelCase   )
				A	 =      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	 =      original_model({'image': original_pixel_values, 'text_input': [prompt]}   ).logits
												A	 =      hf_model(**UpperCAmelCase   ).logits
								else:
												A	 =      original_model(
												    {'image': original_pixel_values, 'text_input': [prompt], 'text_output': ['\n']}   ).logits
												A	 =      tokenizer('\n',						return_tensors='pt'   ).input_ids.to(UpperCAmelCase   )
												A	 =      label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id,						-1_00   )
												A	 =      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	 =      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	 =      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	 =      hf_model.generate(
				    **UpperCAmelCase,						do_sample=UpperCAmelCase,						num_beams=5,						max_length=2_56,						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	 =      2
				print('Original generation:',						UpperCAmelCase   )
				A	 =      processor.batch_decode(UpperCAmelCase,						skip_special_tokens=UpperCAmelCase   )
				A	 =      [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__":
					lowerCAmelCase_           = argparse.ArgumentParser()
					lowerCAmelCase_           = [
					    '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_           = parser.parse_args()

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













def      snake_case		(							UpperCAmelCase	:       Optional[int],						UpperCAmelCase	:       Union[str, Any]   ):
				A	 =      ''
				for i in table:
								res += inp[i - 1]
				return res







def      snake_case		(							UpperCAmelCase	:       Union[str, Any]   ):
				return data[1:] + data[0]







def      snake_case		(							UpperCAmelCase	:       Union[str, Any],						UpperCAmelCase	:       Dict   ):
				A	 =      ''
				for i in range(len(UpperCAmelCase   )   ):
								if a[i] == b[i]:
												res += "0"
								else:
												res += "1"
				return res







def      snake_case		(							UpperCAmelCase	:       int,						UpperCAmelCase	:       Optional[Any]   ):
				A	 =      int('0b' + data[0] + data[-1],						2   )
				A	 =      int('0b' + data[1:3],						2   )
				return bin(s[row][col]   )[2:]







def      snake_case		(							UpperCAmelCase	:       Optional[Any],						UpperCAmelCase	:       Any,						UpperCAmelCase	:       Union[str, Any],						UpperCAmelCase	:       Optional[Any],						UpperCAmelCase	:       Optional[int]   ):
				A	 =      message[:4]
				A	 =      message[4:]
				A	 =      apply_table(UpperCAmelCase,						UpperCAmelCase   )
				A	 =      xor(UpperCAmelCase,						UpperCAmelCase   )
				A	 =      apply_sbox(UpperCAmelCase,						temp[:4]   )  # noqa: E741
				A	 =      apply_sbox(UpperCAmelCase,						temp[4:]   )
				A	 =      '0' * (2 - len(UpperCAmelCase   )) + l  # noqa: E741
				A	 =      '0' * (2 - len(UpperCAmelCase   )) + r
				A	 =      apply_table(l + r,						UpperCAmelCase   )
				A	 =      xor(UpperCAmelCase,						UpperCAmelCase   )
				return temp + right


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

					lowerCAmelCase_           = [6, 3, 7, 4, 8, 5, 10, 9]
					lowerCAmelCase_           = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
					lowerCAmelCase_           = [2, 4, 3, 1]
					lowerCAmelCase_           = [2, 6, 3, 1, 4, 8, 5, 7]
					lowerCAmelCase_           = [4, 1, 3, 5, 7, 2, 8, 6]
					lowerCAmelCase_           = [4, 1, 2, 3, 2, 3, 4, 1]
					lowerCAmelCase_           = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
					lowerCAmelCase_           = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

					# key generation
					lowerCAmelCase_           = apply_table(key, paa_table)
					lowerCAmelCase_           = temp[:5]
					lowerCAmelCase_           = temp[5:]
					lowerCAmelCase_           = left_shift(left)
					lowerCAmelCase_           = left_shift(right)
					lowerCAmelCase_           = apply_table(left + right, pa_table)
					lowerCAmelCase_           = left_shift(left)
					lowerCAmelCase_           = left_shift(right)
					lowerCAmelCase_           = left_shift(left)
					lowerCAmelCase_           = left_shift(right)
					lowerCAmelCase_           = apply_table(left + right, pa_table)

					# encryption
					lowerCAmelCase_           = apply_table(message, IP)
					lowerCAmelCase_           = function(expansion, sa, sa, keya, temp)
					lowerCAmelCase_           = temp[4:] + temp[:4]
					lowerCAmelCase_           = function(expansion, sa, sa, keya, temp)
					lowerCAmelCase_           = apply_table(temp, IP_inv)
					print('Cipher text is:', CT)

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





