






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      __A					(     ):

					'''simple docstring'''







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

					return image




def      __A					(     _lowercase ):

					'''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      __A					(     _lowercase					,			_lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= dct.pop(_lowercase )
					_A								= val




def      __A					(     _lowercase					,			_lowercase ):

					'''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(_lowercase					,			requires_grad=_lowercase ), v_bias) )
										_A								= qkv_bias




def      __A					(     _lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= 3_64 if '''coco''' in model_name else 2_24
					_A								= 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:
										_A								= OPTConfig.from_pretrained('''facebook/opt-2.7b'''					,			eos_token_id=_lowercase ).to_dict()
					elif "opt-6.7b" in model_name:
										_A								= OPTConfig.from_pretrained('''facebook/opt-6.7b'''					,			eos_token_id=_lowercase ).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=_lowercase					,			text_config=_lowercase )

					return config, image_size




@torch.no_grad()
def      __A					(     _lowercase					,			_lowercase=None					,			_lowercase=False ):

					'''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=_lowercase ).input_ids[0]
					_A							,_A								= get_blipa_config(_lowercase					,			eos_token_id=_lowercase )

					_A								= BlipaForConditionalGeneration(_lowercase ).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=_lowercase					,			model_type=_lowercase					,			is_eval=_lowercase					,			device=_lowercase )
					original_model.eval()
					print('''Done!''' )

					# update state dict keys
					_A								= original_model.state_dict()
					_A								= 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():
										_A								= state_dict.pop(_lowercase )
										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(_lowercase					,			_lowercase )

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

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

					# create processor
					_A								= BlipImageProcessor(
					    size={'''height''': image_size, '''width''': image_size}					,			image_mean=_lowercase					,			image_std=_lowercase )
					_A								= BlipaProcessor(image_processor=_lowercase					,			tokenizer=_lowercase )
					_A								= 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:
															_A								= original_model({'''image''': original_pixel_values, '''text_input''': ['''''']} ).logits
															_A								= hf_model(_lowercase					,			_lowercase ).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					,			-1_00 )
															_A								= 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":
										_A								= torch.tensor(
										    [[-41.58_50, -4.44_40, -8.99_22], [-47.43_22, -5.91_43, -1.73_40]]					,			device=_lowercase )
										assert torch.allclose(logits[0, :3, :3]					,			_lowercase					,			atol=1e-4 )
					elif model_name == "blip2-flan-t5-xl-coco":
										_A								= torch.tensor(
										    [[-57.01_09, -9.89_67, -12.62_80], [-68.65_78, -12.71_91, -10.50_65]]					,			device=_lowercase )
					else:
										# cast to same type
										_A								= logits.dtype
										assert torch.allclose(original_logits.to(_lowercase )					,			_lowercase					,			atol=1e-2 )
					print('''Looks ok!''' )

					print('''Generating a caption...''' )
					_A								= ''''''
					_A								= tokenizer(_lowercase					,			return_tensors='''pt''' ).input_ids.to(_lowercase )

					_A								= original_model.generate({'''image''': original_pixel_values} )
					_A								= 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 )
					_A								= input_ids.shape[1]
					_A								= processor.batch_decode(outputs[:, prompt_length:]					,			skip_special_tokens=_lowercase )
					_A								= [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__":
				__A      =				argparse.ArgumentParser()
				__A      =				[
				    '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',
				)

				__A      =				parser.parse_args()

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











import math




def      __A					(     _lowercase ):

					'''simple docstring'''







					_A								= []
					_A								= 2
					_A								= int(math.sqrt(_lowercase ) )  # Size of every segment
					_A								= [True] * (end + 1)
					_A								= []

					while start <= end:
										if temp[start] is True:
															in_prime.append(_lowercase )
															for i in range(start * start					,			end + 1					,			_lowercase ):
																				_A								= False
										start += 1
					prime += in_prime

					_A								= end + 1
					_A								= min(2 * end					,			_lowercase )

					while low <= n:
										_A								= [True] * (high - low + 1)
										for each in in_prime:
															_A								= math.floor(low / each ) * each
															if t < low:
																				t += each

															for j in range(_lowercase					,			high + 1					,			_lowercase ):
																				_A								= False

										for j in range(len(_lowercase ) ):
															if temp[j] is True:
																				prime.append(j + low )

										_A								= high + 1
										_A								= min(high + end					,			_lowercase )

					return prime


print(sieve(10**6))



