




'''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   lowercase__(			):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						'https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png'
      SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						Image.open(requests.get(__UpperCamelCase      ,stream=__UpperCamelCase    ).raw    ).convert('RGB'    )

      return image




def   lowercase__(			__UpperCamelCase:					Optional[int]    ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      Optional[int]    					=						[]
      # 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   lowercase__(			__UpperCamelCase:					Union[str, Any]      ,__UpperCamelCase:					int      ,__UpperCamelCase:					Optional[int]    ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						dct.pop(__UpperCamelCase    )
      SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						val




def   lowercase__(			__UpperCamelCase:					str      ,__UpperCamelCase:					str    ):

      """simple docstring"""






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

            # next, set bias in the state dict
            SCREAMING_SNAKE_CASE   :      Optional[int]    					=						torch.cat((q_bias, torch.zeros_like(__UpperCamelCase      ,requires_grad=__UpperCamelCase    ), v_bias)    )
            SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						qkv_bias




def   lowercase__(			__UpperCamelCase:					Tuple      ,__UpperCamelCase:					List[str]    ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      List[Any]    					=						3_64 if 'coco' in model_name else 2_24
      SCREAMING_SNAKE_CASE   :      Dict    					=						BlipaVisionConfig(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 "opt-2.7b" in model_name:
            SCREAMING_SNAKE_CASE   :      Optional[int]    					=						OPTConfig.from_pretrained('facebook/opt-2.7b'      ,eos_token_id=__UpperCamelCase    ).to_dict()
      elif "opt-6.7b" in model_name:
            SCREAMING_SNAKE_CASE   :      List[str]    					=						OPTConfig.from_pretrained('facebook/opt-6.7b'      ,eos_token_id=__UpperCamelCase    ).to_dict()
      elif "t5-xl" in model_name:
            SCREAMING_SNAKE_CASE   :      int    					=						TaConfig.from_pretrained('google/flan-t5-xl'      ,dense_act_fn='gelu'      ,bos_token_id=1    ).to_dict()
      elif "t5-xxl" in model_name:
            SCREAMING_SNAKE_CASE   :      Any    					=						TaConfig.from_pretrained('google/flan-t5-xxl'      ,dense_act_fn='gelu'      ,bos_token_id=1    ).to_dict()

      SCREAMING_SNAKE_CASE   :      Optional[int]    					=						BlipaConfig(vision_config=__UpperCamelCase      ,text_config=__UpperCamelCase    )

      return config, image_size




@torch.no_grad()
def   lowercase__(			__UpperCamelCase:					Tuple      ,__UpperCamelCase:					Union[str, Any]=None      ,__UpperCamelCase:					Dict=False    ):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      List[Any]    					=						(
          AutoTokenizer.from_pretrained('facebook/opt-2.7b'    )
          if 'opt' in model_name
          else AutoTokenizer.from_pretrained('google/flan-t5-xl'    )
      )
      SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						tokenizer('\n'      ,add_special_tokens=__UpperCamelCase    ).input_ids[0]
      SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      str    					=						get_blipa_config(__UpperCamelCase      ,eos_token_id=__UpperCamelCase    )

      SCREAMING_SNAKE_CASE   :      Any    					=						BlipaForConditionalGeneration(__UpperCamelCase    ).eval()

      SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						{
          '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'),
      }

      SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      List[str]    					=						model_name_to_original[model_name]

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

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

      # read in qv biases
      read_in_q_v_bias(__UpperCamelCase      ,__UpperCamelCase    )

      SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      int    					=						hf_model.load_state_dict(__UpperCamelCase      ,strict=__UpperCamelCase    )
      assert len(__UpperCamelCase    ) == 0
      assert unexpected_keys == ["qformer.embeddings.position_ids"]

      SCREAMING_SNAKE_CASE   :      str    					=						load_demo_image()
      SCREAMING_SNAKE_CASE   :      Any    					=						vis_processors['eval'](__UpperCamelCase    ).unsqueeze(0    ).to(__UpperCamelCase    )
      SCREAMING_SNAKE_CASE   :      Dict    					=						tokenizer(['\n']      ,return_tensors='pt'    ).input_ids.to(__UpperCamelCase    )

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

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

      original_model.to(__UpperCamelCase    )
      hf_model.to(__UpperCamelCase    )
      with torch.no_grad():
            if "opt" in model_name:
                  SCREAMING_SNAKE_CASE   :      Any    					=						original_model({'image': original_pixel_values, 'text_input': ['']}    ).logits
                  SCREAMING_SNAKE_CASE   :      Dict    					=						hf_model(__UpperCamelCase      ,__UpperCamelCase    ).logits
            else:
                  SCREAMING_SNAKE_CASE   :      Tuple    					=						original_model(
                      {'image': original_pixel_values, 'text_input': ['\n'], 'text_output': ['\n']}    ).logits
                  SCREAMING_SNAKE_CASE   :      Dict    					=						input_ids.masked_fill(input_ids == tokenizer.pad_token_id      ,-1_00    )
                  SCREAMING_SNAKE_CASE   :      Tuple    					=						hf_model(__UpperCamelCase      ,__UpperCamelCase      ,labels=__UpperCamelCase    ).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":
            SCREAMING_SNAKE_CASE   :      int    					=						torch.tensor(
                [[-4_1.5_8_5_0, -4.4_4_4_0, -8.9_9_2_2], [-4_7.4_3_2_2, -5.9_1_4_3, -1.7_3_4_0]]      ,device=__UpperCamelCase    )
            assert torch.allclose(logits[0, :3, :3]      ,__UpperCamelCase      ,atol=1e-4    )
      elif model_name == "blip2-flan-t5-xl-coco":
            SCREAMING_SNAKE_CASE   :      Any    					=						torch.tensor(
                [[-5_7.0_1_0_9, -9.8_9_6_7, -1_2.6_2_8_0], [-6_8.6_5_7_8, -1_2.7_1_9_1, -1_0.5_0_6_5]]      ,device=__UpperCamelCase    )
      else:
            # cast to same type
            SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						logits.dtype
            assert torch.allclose(original_logits.to(__UpperCamelCase    )      ,__UpperCamelCase      ,atol=1e-2    )
      print('Looks ok!'    )

      print('Generating a caption...'    )
      SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						''
      SCREAMING_SNAKE_CASE   :      str    					=						tokenizer(__UpperCamelCase      ,return_tensors='pt'    ).input_ids.to(__UpperCamelCase    )

      SCREAMING_SNAKE_CASE   :      List[Any]    					=						original_model.generate({'image': original_pixel_values}    )
      SCREAMING_SNAKE_CASE   :      Tuple    					=						hf_model.generate(
          __UpperCamelCase      ,__UpperCamelCase      ,do_sample=__UpperCamelCase      ,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:'      ,__UpperCamelCase    )
      SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						input_ids.shape[1]
      SCREAMING_SNAKE_CASE   :      Dict    					=						processor.batch_decode(outputs[:, prompt_length:]      ,skip_special_tokens=__UpperCamelCase    )
      SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						[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"nielsr/{model_name}"    )
            hf_model.push_to_hub(f"nielsr/{model_name}"    )


if __name__ == "__main__":
      UpperCamelCase_    	=				argparse.ArgumentParser()
      UpperCamelCase_    	=				[
          "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",
      )

      UpperCamelCase_    	=				parser.parse_args()

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










"""simple docstring"""



def 	SCREAMING_SNAKE_CASE__       (  snake_case       : list				)->		list:






     '''simple docstring'''



     UpperCAmelCase__						:    List[str]							=							False
     while is_sorted is False:  # Until all the indices are traversed keep looping
          UpperCAmelCase__						:    List[Any]							=							True
          for i in range(0			,					len(snake_case				) - 1			,					2				):  # iterating over all even indices
               if input_list[i] > input_list[i + 1]:
                    UpperCAmelCase__							,				UpperCAmelCase__						:    Optional[int]							=							input_list[i + 1], input_list[i]
                    # swapping if elements not in order
                    UpperCAmelCase__						:    int							=							False

          for i in range(1			,					len(snake_case				) - 1			,					2				):  # iterating over all odd indices
               if input_list[i] > input_list[i + 1]:
                    UpperCAmelCase__							,				UpperCAmelCase__						:    Optional[int]							=							input_list[i + 1], input_list[i]
                    # swapping if elements not in order
                    UpperCAmelCase__						:    str							=							False
     return input_list


if __name__ == "__main__":
 print("""Enter list to be sorted""")
 _lowerCAmelCase	:	List[str]				=      [int(x) for x in input().split()]
 # inputing elements of the list in one line
 _lowerCAmelCase	:	Optional[int]				=      odd_even_sort(input_list)
 print("""The sorted list is""")
 print(sorted_list)


