



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  lowerCamelCase_	(      )       ->							str:

							'''simple docstring'''






							A      						=    'https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'
							A      						=    Image.open(requests.get(lowerCAmelCase__			,	stream=lowerCAmelCase__				).raw				).convert('RGB'				)

							return image






def  lowerCamelCase_	(      lowerCAmelCase__	:	str				)       ->							Tuple:

							'''simple docstring'''






							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.layernorm.weight')				)
							rename_keys.append(('Qformer.bert.embeddings.LayerNorm.bias', 'qformer.layernorm.bias')				)

							# fmt: on
							return rename_keys






def  lowerCamelCase_	(      lowerCAmelCase__	:	Tuple			,	lowerCAmelCase__	:	str			,	lowerCAmelCase__	:	str				)       ->							Dict:

							'''simple docstring'''






							A      						=    dct.pop(lowerCAmelCase__				)
							A      						=    val






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[int]			,	lowerCAmelCase__	:	Any				)       ->							int:

							'''simple docstring'''






							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(lowerCAmelCase__			,	requires_grad=lowerCAmelCase__				), v_bias)				)
														A      						=    qkv_bias






def  lowerCamelCase_	(      lowerCAmelCase__	:	Optional[Any]			,	lowerCAmelCase__	:	List[Any]				)       ->							Optional[int]:

							'''simple docstring'''






							A      						=    364 if 'coco' in model_name else 224
							A      						=    BlipaVisionConfig(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 "opt-2.7b" in model_name:
														A      						=    OPTConfig.from_pretrained('facebook/opt-2.7b'			,	eos_token_id=lowerCAmelCase__				).to_dict()
							elif "opt-6.7b" in model_name:
														A      						=    OPTConfig.from_pretrained('facebook/opt-6.7b'			,	eos_token_id=lowerCAmelCase__				).to_dict()
							elif "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()

							A      						=    BlipaConfig(vision_config=lowerCAmelCase__			,	text_config=lowerCAmelCase__				)

							return config, image_size






@torch.no_grad()
def  lowerCamelCase_	(      lowerCAmelCase__	:	Any			,	lowerCAmelCase__	:	str=None			,	lowerCAmelCase__	:	Any=False				)       ->							Optional[Any]:

							'''simple docstring'''






							A      						=    (
							    AutoTokenizer.from_pretrained('facebook/opt-2.7b'				)
							    if 'opt' in model_name
							    else AutoTokenizer.from_pretrained('google/flan-t5-xl'				)
							)
							A      						=    tokenizer('\n'			,	add_special_tokens=lowerCAmelCase__				).input_ids[0]
							A						,   A      						=    get_blipa_config(lowerCAmelCase__			,	eos_token_id=lowerCAmelCase__				)

							A      						=    BlipaForConditionalGeneration(lowerCAmelCase__				).eval()

							A      						=    {
							    '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'),
							}

							A						,   A      						=    model_name_to_original[model_name]

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

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

							# read in qv biases
							read_in_q_v_bias(lowerCAmelCase__			,	lowerCAmelCase__				)

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

							A      						=    load_demo_image()
							A      						=    vis_processors['eval'](lowerCAmelCase__				).unsqueeze(0				).to(lowerCAmelCase__				)
							A      						=    tokenizer(['\n']			,	return_tensors='pt'				).input_ids.to(lowerCAmelCase__				)

							# create processor
							A      						=    BlipImageProcessor(
							    size={'height': image_size, 'width': image_size}			,	image_mean=lowerCAmelCase__			,	image_std=lowerCAmelCase__				)
							A      						=    BlipaProcessor(image_processor=lowerCAmelCase__			,	tokenizer=lowerCAmelCase__				)
							A      						=    processor(images=lowerCAmelCase__			,	return_tensors='pt'				).pixel_values.to(lowerCAmelCase__				)

							# make sure processor creates exact same pixel values
							assert torch.allclose(lowerCAmelCase__			,	lowerCAmelCase__				)

							original_model.to(lowerCAmelCase__				)
							hf_model.to(lowerCAmelCase__				)
							with torch.no_grad():
														if "opt" in model_name:
																					A      						=    original_model({'image': original_pixel_values, 'text_input': ['']}				).logits
																					A      						=    hf_model(lowerCAmelCase__			,	lowerCAmelCase__				).logits
														else:
																					A      						=    original_model(
																					    {'image': original_pixel_values, 'text_input': ['\n'], 'text_output': ['\n']}				).logits
																					A      						=    input_ids.masked_fill(input_ids == tokenizer.pad_token_id			,	-100				)
																					A      						=    hf_model(lowerCAmelCase__			,	lowerCAmelCase__			,	labels=lowerCAmelCase__				).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":
														A      						=    torch.tensor(
														    [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]]			,	device=lowerCAmelCase__				)
														assert torch.allclose(logits[0, :3, :3]			,	lowerCAmelCase__			,	atol=1E-4				)
							elif model_name == "blip2-flan-t5-xl-coco":
														A      						=    torch.tensor(
														    [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]]			,	device=lowerCAmelCase__				)
							else:
														# cast to same type
														A      						=    logits.dtype
														assert torch.allclose(original_logits.to(lowerCAmelCase__				)			,	lowerCAmelCase__			,	atol=1E-2				)
							print('Looks ok!'				)

							print('Generating a caption...'				)
							A      						=    ''
							A      						=    tokenizer(lowerCAmelCase__			,	return_tensors='pt'				).input_ids.to(lowerCAmelCase__				)

							A      						=    original_model.generate({'image': original_pixel_values}				)
							A      						=    hf_model.generate(
							    lowerCAmelCase__			,	lowerCAmelCase__			,	do_sample=lowerCAmelCase__			,	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:'			,	lowerCAmelCase__				)
							A      						=    input_ids.shape[1]
							A      						=    processor.batch_decode(outputs[:, prompt_length:]			,	skip_special_tokens=lowerCAmelCase__				)
							A      						=    [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'''nielsr/{model_name}'''				)
														hf_model.push_to_hub(F'''nielsr/{model_name}'''				)


if __name__ == "__main__":
				__snake_case     :str			       =argparse.ArgumentParser()
				__snake_case     :Optional[Any]			       =[
				    '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',
				)

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

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




UpperCAmelCase_		 =					2_5_6
# Modulus to hash a string
UpperCAmelCase_		 =					1_0_0_0_0_0_3

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:str	,   _snake_case	:str				)  ->     bool:
   _A      =       len(_snake_case				)
   _A      =       len(_snake_case				)
   if p_len > t_len:
      return False

   _A      =       0
   _A      =       0
   _A      =       1

   # Calculating the hash of pattern and substring of text
   for i in range(_snake_case				):
      _A      =       (ord(pattern[i]				) + p_hash * alphabet_size) % modulus
      _A      =       (ord(text[i]				) + text_hash * alphabet_size) % modulus
      if i == p_len - 1:
         continue
      _A      =       (modulus_power * alphabet_size) % modulus

   for i in range(0	,   t_len - p_len + 1				):
      if text_hash == p_hash and text[i : i + p_len] == pattern:
         return True
      if i == t_len - p_len:
         continue
      # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
      _A      =       (
          (text_hash - ord(text[i]				) * modulus_power) * alphabet_size
          + ord(text[i + p_len]				)
      ) % modulus
   return False

def 	SCREAMING_SNAKE_CASE_							(	)  ->     None:
   _A      =       '''abc1abc12'''
   _A      =       '''alskfjaldsabc1abc1abc12k23adsfabcabc'''
   _A      =       '''alskfjaldsk23adsfabcabc'''
   assert rabin_karp(_snake_case	,   _snake_case				) and not rabin_karp(_snake_case	,   _snake_case				)

   # Test 2)
   _A      =       '''ABABX'''
   _A      =       '''ABABZABABYABABX'''
   assert rabin_karp(_snake_case	,   _snake_case				)

   # Test 3)
   _A      =       '''AAAB'''
   _A      =       '''ABAAAAAB'''
   assert rabin_karp(_snake_case	,   _snake_case				)

   # Test 4)
   _A      =       '''abcdabcy'''
   _A      =       '''abcxabcdabxabcdabcdabcy'''
   assert rabin_karp(_snake_case	,   _snake_case				)

   # Test 5)
   _A      =       '''Lü'''
   _A      =       '''Lüsai'''
   assert rabin_karp(_snake_case	,   _snake_case				)
   _A      =       '''Lue'''
   assert not rabin_karp(_snake_case	,   _snake_case				)
   print('''Success.'''				)


if __name__ == "__main__":
   test_rabin_karp()



