



'''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_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   a_   (		)    ->  int:
      __snake_case :   List[str]													=    'https://raw.githubusercontent.com/salesforce/LAVIS/main/docs/_static/Confusing-Pictures.jpg'
      __snake_case :   Optional[Any]													=    Image.open(requests.get(_UpperCAmelCase ,stream=_UpperCAmelCase				).raw				).convert('RGB'				)

      return image





def   a_   (		_UpperCAmelCase    :      int				)    ->  str:
      __snake_case :   List[Any]													=    []
      # 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   a_   (		_UpperCAmelCase    :      Optional[Any] ,_UpperCAmelCase    :      Optional[Any] ,_UpperCAmelCase    :      str				)    ->  Optional[Any]:
      __snake_case :   int													=    dct.pop(_UpperCAmelCase				)
      __snake_case :   List[str]													=    val





def   a_   (		_UpperCAmelCase    :      int ,_UpperCAmelCase    :      Union[str, Any]				)    ->  int:
      for i in range(config.vision_config.num_hidden_layers				):
            # read in original q and v biases
            __snake_case :   List[Any]													=    state_dict.pop(f'''visual_encoder.blocks.{i}.attn.q_bias'''				)
            __snake_case :   Dict													=    state_dict.pop(f'''visual_encoder.blocks.{i}.attn.v_bias'''				)

            # next, set bias in the state dict
            __snake_case :   Optional[int]													=    torch.cat((q_bias, torch.zeros_like(_UpperCAmelCase ,requires_grad=_UpperCAmelCase				), v_bias)				)
            __snake_case :   Dict													=    qkv_bias





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

      return config, image_size





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

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

      __snake_case							,     __snake_case :   Tuple													=    get_blipa_config(_UpperCAmelCase				)
      __snake_case :   str													=    InstructBlipForConditionalGeneration(_UpperCAmelCase				).eval()

      __snake_case :   List[Any]													=    {
          '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'),
      }

      __snake_case							,     __snake_case :   Dict													=    model_name_to_original[model_name]

      # load original model
      print('Loading original model...'				)
      __snake_case :   Optional[Any]													=    'cuda:1' if torch.cuda.is_available() else 'cpu'
      __snake_case :   List[str]													=    'cuda:2' if torch.cuda.is_available() else 'cpu'
      __snake_case							,     __snake_case							,     __snake_case :   Optional[int]													=    load_model_and_preprocess(
          name=_UpperCAmelCase ,model_type=_UpperCAmelCase ,is_eval=_UpperCAmelCase ,device=_UpperCAmelCase				)
      original_model.eval()
      print('Done!'				)

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

      __snake_case :   List[Any]													=    load_demo_image()
      __snake_case :   Any													=    'What is unusual about this image?'

      # create processor
      __snake_case :   Tuple													=    BlipImageProcessor(
          size={'height': image_size, 'width': image_size} ,image_mean=_UpperCAmelCase ,image_std=_UpperCAmelCase				)
      __snake_case :   Optional[int]													=    InstructBlipProcessor(
          image_processor=_UpperCAmelCase ,tokenizer=_UpperCAmelCase ,qformer_tokenizer=_UpperCAmelCase ,)
      __snake_case :   Tuple													=    processor(images=_UpperCAmelCase ,text=_UpperCAmelCase ,return_tensors='pt'				).to(_UpperCAmelCase				)

      # make sure processor creates exact same pixel values
      __snake_case :   Any													=    vis_processors['eval'](_UpperCAmelCase				).unsqueeze(0				).to(_UpperCAmelCase				)
      __snake_case :   List[Any]													=    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:
                  __snake_case :   str													=    original_model({'image': original_pixel_values, 'text_input': [prompt]}				).logits
                  __snake_case :   Any													=    hf_model(**_UpperCAmelCase				).logits
            else:
                  __snake_case :   Optional[Any]													=    original_model(
                      {'image': original_pixel_values, 'text_input': [prompt], 'text_output': ['\n']}				).logits
                  __snake_case :   Union[str, Any]													=    tokenizer('\n' ,return_tensors='pt'				).input_ids.to(_UpperCAmelCase				)
                  __snake_case :   List[Any]													=    label_input_ids.masked_fill(label_input_ids == tokenizer.pad_token_id ,-1_00				)
                  __snake_case :   Union[str, Any]													=    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
      __snake_case :   Optional[Any]													=    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...'				)
      __snake_case :   List[str]													=    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...'				)
      __snake_case :   Tuple													=    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?
            __snake_case :   List[Any]													=    2
      print('Original generation:' ,_UpperCAmelCase				)
      __snake_case :   Dict													=    processor.batch_decode(_UpperCAmelCase ,skip_special_tokens=_UpperCAmelCase				)
      __snake_case :   List[str]													=    [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__":
    A__    :   Union[str, Any]           =					argparse.ArgumentParser()
    A__    :   Union[str, Any]           =					[
        '''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''',
    )

    A__    :   Dict           =					parser.parse_args()

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








'''simple docstring'''





import functools





def   a_   (		_UpperCAmelCase    :      list[int] ,_UpperCAmelCase    :      list[int]				)    ->  int:

      # Validation
      if not isinstance(_UpperCAmelCase ,_UpperCAmelCase				) or not all(isinstance(_UpperCAmelCase ,_UpperCAmelCase				) for day in days				):
            raise ValueError('The parameter days should be a list of integers'				)

      if len(_UpperCAmelCase				) != 3 or not all(isinstance(_UpperCAmelCase ,_UpperCAmelCase				) for cost in costs				):
            raise ValueError('The parameter costs should be a list of three integers'				)

      if len(_UpperCAmelCase				) == 0:
            return 0

      if min(_UpperCAmelCase				) <= 0:
            raise ValueError('All days elements should be greater than 0'				)

      if max(_UpperCAmelCase				) >= 3_66:
            raise ValueError('All days elements should be less than 366'				)

      __snake_case :   str													=    set(_UpperCAmelCase				)

      @functools.cache
      def dynamic_programming(_UpperCAmelCase    :      int				) -> int:
            if index > 3_65:
                  return 0

            if index not in days_set:
                  return dynamic_programming(index + 1				)

            return min(
                costs[0] + dynamic_programming(index + 1				) ,costs[1] + dynamic_programming(index + 7				) ,costs[2] + dynamic_programming(index + 30				) ,)

      return dynamic_programming(1				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()



