





"""simple docstring"""





import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english




@require_tokenizers
class 							snake_case							(			__UpperCAmelCase      ,  unittest.TestCase ):

      '''simple docstring'''



      _A     :       Union[str, Any]         =       BertTokenizer
      _A     :       Tuple         =       BertTokenizerFast
      _A     :       str         =       True
      _A     :       Any         =       True
      _A     :       Union[str, Any]         =       filter_non_english

      def       A_					(							self       :      Dict ):


        '''simple docstring'''




        super().setUp()

        __UpperCAmelCase    :						List[Any]       =						[
            '''[UNK]''',
            '''[CLS]''',
            '''[SEP]''',
            '''[PAD]''',
            '''[MASK]''',
            '''want''',
            '''##want''',
            '''##ed''',
            '''wa''',
            '''un''',
            '''runn''',
            '''##ing''',
            ''',''',
            '''low''',
            '''lowest''',
        ]
        __UpperCAmelCase    :						int       =						os.path.join(self.tmpdirname						,				VOCAB_FILES_NAMES['''vocab_file'''] )
        with open(self.vocab_file						,				'''w'''						,				encoding='''utf-8''' ) as vocab_writer:
          vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) )

      def       A_					(							self       :      List[str]						,				__lowercase       :      List[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						int       =						'''UNwant\u00E9d,running'''
        __UpperCAmelCase    :						str       =						'''unwanted, running'''
        return input_text, output_text

      def       A_					(							self       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						int       =						self.tokenizer_class(self.vocab_file )

        __UpperCAmelCase    :						Union[str, Any]       =						tokenizer.tokenize('''UNwant\u00E9d,running''' )
        self.assertListEqual(__lowercase						,				['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''] )
        self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowercase )						,				[9, 6, 7, 12, 10, 11] )

      def       A_					(							self       :      List[Any] ):


        '''simple docstring'''




        if not self.test_rust_tokenizer:
          return

        __UpperCAmelCase    :						int       =						self.get_tokenizer()
        __UpperCAmelCase    :						int       =						self.get_rust_tokenizer()

        __UpperCAmelCase    :						Tuple       =						'''UNwant\u00E9d,running'''

        __UpperCAmelCase    :						Union[str, Any]       =						tokenizer.tokenize(__lowercase )
        __UpperCAmelCase    :						int       =						rust_tokenizer.tokenize(__lowercase )
        self.assertListEqual(__lowercase						,				__lowercase )

        __UpperCAmelCase    :						int       =						tokenizer.encode(__lowercase						,				add_special_tokens=__lowercase )
        __UpperCAmelCase    :						int       =						rust_tokenizer.encode(__lowercase						,				add_special_tokens=__lowercase )
        self.assertListEqual(__lowercase						,				__lowercase )

        __UpperCAmelCase    :						List[Any]       =						self.get_rust_tokenizer()
        __UpperCAmelCase    :						Tuple       =						tokenizer.encode(__lowercase )
        __UpperCAmelCase    :						Optional[int]       =						rust_tokenizer.encode(__lowercase )
        self.assertListEqual(__lowercase						,				__lowercase )

        # With lower casing
        __UpperCAmelCase    :						Union[str, Any]       =						self.get_tokenizer(do_lower_case=__lowercase )
        __UpperCAmelCase    :						List[Any]       =						self.get_rust_tokenizer(do_lower_case=__lowercase )

        __UpperCAmelCase    :						Tuple       =						'''UNwant\u00E9d,running'''

        __UpperCAmelCase    :						Optional[int]       =						tokenizer.tokenize(__lowercase )
        __UpperCAmelCase    :						str       =						rust_tokenizer.tokenize(__lowercase )
        self.assertListEqual(__lowercase						,				__lowercase )

        __UpperCAmelCase    :						Tuple       =						tokenizer.encode(__lowercase						,				add_special_tokens=__lowercase )
        __UpperCAmelCase    :						Optional[int]       =						rust_tokenizer.encode(__lowercase						,				add_special_tokens=__lowercase )
        self.assertListEqual(__lowercase						,				__lowercase )

        __UpperCAmelCase    :						List[str]       =						self.get_rust_tokenizer()
        __UpperCAmelCase    :						Dict       =						tokenizer.encode(__lowercase )
        __UpperCAmelCase    :						Tuple       =						rust_tokenizer.encode(__lowercase )
        self.assertListEqual(__lowercase						,				__lowercase )

      def       A_					(							self       :      Optional[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Tuple       =						BasicTokenizer()

        self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz''' )						,				['''ah''', '''\u535A''', '''\u63A8''', '''zz'''] )

      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						BasicTokenizer(do_lower_case=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''' )						,				['''hello''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )						,				['''hello'''] )

      def       A_					(							self       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Union[str, Any]       =						BasicTokenizer(do_lower_case=__lowercase						,				strip_accents=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )						,				['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )						,				['''h\u00E9llo'''] )

      def       A_					(							self       :      Tuple ):


        '''simple docstring'''




        __UpperCAmelCase    :						Union[str, Any]       =						BasicTokenizer(do_lower_case=__lowercase						,				strip_accents=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )						,				['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )						,				['''hello'''] )

      def       A_					(							self       :      str ):


        '''simple docstring'''




        __UpperCAmelCase    :						str       =						BasicTokenizer(do_lower_case=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )						,				['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''] )
        self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' )						,				['''hello'''] )

      def       A_					(							self       :      Tuple ):


        '''simple docstring'''




        __UpperCAmelCase    :						Dict       =						BasicTokenizer(do_lower_case=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''' )						,				['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )

      def       A_					(							self       :      Optional[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[Any]       =						BasicTokenizer(do_lower_case=__lowercase						,				strip_accents=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )						,				['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )

      def       A_					(							self       :      Optional[Any] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						BasicTokenizer(do_lower_case=__lowercase						,				strip_accents=__lowercase )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''' )						,				['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''] )

      def       A_					(							self       :      str ):


        '''simple docstring'''




        __UpperCAmelCase    :						str       =						BasicTokenizer(do_lower_case=__lowercase						,				never_split=['''[UNK]'''] )

        self.assertListEqual(
            tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]''' )						,				['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]'''] )

      def       A_					(							self       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[int]       =						BasicTokenizer()
        __UpperCAmelCase    :						int       =						'''a\n\'ll !!to?\'d of, can\'t.'''
        __UpperCAmelCase    :						int       =						['''a''', '''\'''', '''ll''', '''!''', '''!''', '''to''', '''?''', '''\'''', '''d''', '''of''', ''',''', '''can''', '''\'''', '''t''', '''.''']
        self.assertListEqual(tokenizer.tokenize(__lowercase )						,				__lowercase )

      def       A_					(							self       :      Optional[int] ):


        '''simple docstring'''




        __UpperCAmelCase    :						int       =						['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

        __UpperCAmelCase    :						Dict       =						{}
        for i, token in enumerate(__lowercase ):
          __UpperCAmelCase    :						Dict       =						i
        __UpperCAmelCase    :						Optional[int]       =						WordpieceTokenizer(vocab=__lowercase						,				unk_token='''[UNK]''' )

        self.assertListEqual(tokenizer.tokenize('''''' )						,				[] )

        self.assertListEqual(tokenizer.tokenize('''unwanted running''' )						,				['''un''', '''##want''', '''##ed''', '''runn''', '''##ing'''] )

        self.assertListEqual(tokenizer.tokenize('''unwantedX running''' )						,				['''[UNK]''', '''runn''', '''##ing'''] )

      def       A_					(							self       :      Dict ):


        '''simple docstring'''




        self.assertTrue(_is_whitespace(''' ''' ) )
        self.assertTrue(_is_whitespace('''\t''' ) )
        self.assertTrue(_is_whitespace('''\r''' ) )
        self.assertTrue(_is_whitespace('''\n''' ) )
        self.assertTrue(_is_whitespace('''\u00A0''' ) )

        self.assertFalse(_is_whitespace('''A''' ) )
        self.assertFalse(_is_whitespace('''-''' ) )

      def       A_					(							self       :      int ):


        '''simple docstring'''




        self.assertTrue(_is_control('''\u0005''' ) )

        self.assertFalse(_is_control('''A''' ) )
        self.assertFalse(_is_control(''' ''' ) )
        self.assertFalse(_is_control('''\t''' ) )
        self.assertFalse(_is_control('''\r''' ) )

      def       A_					(							self       :      Any ):


        '''simple docstring'''




        self.assertTrue(_is_punctuation('''-''' ) )
        self.assertTrue(_is_punctuation('''$''' ) )
        self.assertTrue(_is_punctuation('''`''' ) )
        self.assertTrue(_is_punctuation('''.''' ) )

        self.assertFalse(_is_punctuation('''A''' ) )
        self.assertFalse(_is_punctuation(''' ''' ) )

      def       A_					(							self       :      Dict ):


        '''simple docstring'''




        __UpperCAmelCase    :						Union[str, Any]       =						self.get_tokenizer()
        __UpperCAmelCase    :						List[str]       =						self.get_rust_tokenizer()

        # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
        self.assertListEqual([tokenizer.tokenize(__lowercase ) for t in ['''Test''', '''\xad''', '''test''']]						,				[['''[UNK]'''], [], ['''[UNK]''']] )

        self.assertListEqual(
            [rust_tokenizer.tokenize(__lowercase ) for t in ['''Test''', '''\xad''', '''test''']]						,				[['''[UNK]'''], [], ['''[UNK]''']] )

      @slow
      def       A_					(							self       :      List[str] ):


        '''simple docstring'''




        __UpperCAmelCase    :						int       =						self.tokenizer_class.from_pretrained('''bert-base-uncased''' )

        __UpperCAmelCase    :						Optional[Any]       =						tokenizer.encode('''sequence builders'''						,				add_special_tokens=__lowercase )
        __UpperCAmelCase    :						List[Any]       =						tokenizer.encode('''multi-sequence build'''						,				add_special_tokens=__lowercase )

        __UpperCAmelCase    :						List[Any]       =						tokenizer.build_inputs_with_special_tokens(__lowercase )
        __UpperCAmelCase    :						Union[str, Any]       =						tokenizer.build_inputs_with_special_tokens(__lowercase						,				__lowercase )

        assert encoded_sentence == [101] + text + [102]
        assert encoded_pair == [101] + text + [102] + text_a + [102]

      def       A_					(							self       :      Tuple ):


        '''simple docstring'''




        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
            __UpperCAmelCase    :						Any       =						self.rust_tokenizer_class.from_pretrained(__lowercase						,				**__lowercase )

            __UpperCAmelCase    :						str       =						f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
            __UpperCAmelCase    :						Dict       =						tokenizer_r.encode_plus(
                __lowercase						,				return_attention_mask=__lowercase						,				return_token_type_ids=__lowercase						,				return_offsets_mapping=__lowercase						,				add_special_tokens=__lowercase						,				)

            __UpperCAmelCase    :						Union[str, Any]       =						tokenizer_r.do_lower_case if hasattr(__lowercase						,				'''do_lower_case''' ) else False
            __UpperCAmelCase    :						Tuple       =						(
                [
                    ((0, 0), tokenizer_r.cls_token),
                    ((0, 1), '''A'''),
                    ((1, 2), ''','''),
                    ((3, 5), '''na'''),
                    ((5, 6), '''##ï'''),
                    ((6, 8), '''##ve'''),
                    ((9, 15), tokenizer_r.mask_token),
                    ((16, 21), '''Allen'''),
                    ((21, 23), '''##NL'''),
                    ((23, 24), '''##P'''),
                    ((25, 33), '''sentence'''),
                    ((33, 34), '''.'''),
                    ((0, 0), tokenizer_r.sep_token),
                ]
                if not do_lower_case
                else [
                    ((0, 0), tokenizer_r.cls_token),
                    ((0, 1), '''a'''),
                    ((1, 2), ''','''),
                    ((3, 8), '''naive'''),
                    ((9, 15), tokenizer_r.mask_token),
                    ((16, 21), '''allen'''),
                    ((21, 23), '''##nl'''),
                    ((23, 24), '''##p'''),
                    ((25, 33), '''sentence'''),
                    ((33, 34), '''.'''),
                    ((0, 0), tokenizer_r.sep_token),
                ]
            )

            self.assertEqual(
                [e[1] for e in expected_results]						,				tokenizer_r.convert_ids_to_tokens(tokens['''input_ids'''] ) )
            self.assertEqual([e[0] for e in expected_results]						,				tokens['''offset_mapping'''] )







      def       A_					(							self       :      Dict ):


        '''simple docstring'''




        __UpperCAmelCase    :						Optional[Any]       =						['''的''', '''人''', '''有''']
        __UpperCAmelCase    :						int       =						''''''.join(__lowercase )
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ):
            __UpperCAmelCase    :						Tuple       =						True
            __UpperCAmelCase    :						Optional[Any]       =						self.tokenizer_class.from_pretrained(__lowercase						,				**__lowercase )
            __UpperCAmelCase    :						Optional[Any]       =						self.rust_tokenizer_class.from_pretrained(__lowercase						,				**__lowercase )

            __UpperCAmelCase    :						Tuple       =						tokenizer_p.encode(__lowercase						,				add_special_tokens=__lowercase )
            __UpperCAmelCase    :						Optional[Any]       =						tokenizer_r.encode(__lowercase						,				add_special_tokens=__lowercase )

            __UpperCAmelCase    :						Optional[Any]       =						tokenizer_r.convert_ids_to_tokens(__lowercase )
            __UpperCAmelCase    :						int       =						tokenizer_p.convert_ids_to_tokens(__lowercase )

            # it is expected that each Chinese character is not preceded by "##"
            self.assertListEqual(__lowercase						,				__lowercase )
            self.assertListEqual(__lowercase						,				__lowercase )

            __UpperCAmelCase    :						Optional[int]       =						False
            __UpperCAmelCase    :						Union[str, Any]       =						self.rust_tokenizer_class.from_pretrained(__lowercase						,				**__lowercase )
            __UpperCAmelCase    :						Optional[Any]       =						self.tokenizer_class.from_pretrained(__lowercase						,				**__lowercase )

            __UpperCAmelCase    :						Any       =						tokenizer_r.encode(__lowercase						,				add_special_tokens=__lowercase )
            __UpperCAmelCase    :						Union[str, Any]       =						tokenizer_p.encode(__lowercase						,				add_special_tokens=__lowercase )

            __UpperCAmelCase    :						List[str]       =						tokenizer_r.convert_ids_to_tokens(__lowercase )
            __UpperCAmelCase    :						int       =						tokenizer_p.convert_ids_to_tokens(__lowercase )

            # it is expected that only the first Chinese character is not preceded by "##".
            __UpperCAmelCase    :						Optional[Any]       =						[
                f'''##{token}''' if idx != 0 else token for idx, token in enumerate(__lowercase )
            ]
            self.assertListEqual(__lowercase						,				__lowercase )
            self.assertListEqual(__lowercase						,				__lowercase )






"""simple docstring"""





import argparse
import re

import requests
import torch

# git clone https://github.com/salesforce/BLIP.git
from models.blip import blip_decoder
from models.blip_itm import blip_itm
from models.blip_vqa import blip_vqa
from PIL import Image
from torchvision import transforms
from torchvision.transforms.functional import InterpolationMode

from transformers import (
    BertTokenizer,
    BlipConfig,
    BlipForConditionalGeneration,
    BlipForImageTextRetrieval,
    BlipForQuestionAnswering,
)


def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_  )						->Any:





  """simple docstring"""


  __UpperCAmelCase    :						Tuple       =						'''https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg'''
  __UpperCAmelCase    :						Tuple       =						Image.open(requests.get(UpperCAmelCase_  ,			stream=UpperCAmelCase_  ).raw  ).convert('''RGB'''  )

  __UpperCAmelCase    :						Dict       =						transforms.Compose(
      [
          transforms.Resize((image_size, image_size)  ,			interpolation=InterpolationMode.BICUBIC  ),
          transforms.ToTensor(),
          transforms.Normalize((0.48_145_466, 0.4_578_275, 0.40_821_073)  ,			(0.26_862_954, 0.26_130_258, 0.27_577_711)  ),
      ]  )
  __UpperCAmelCase    :						Optional[Any]       =						transform(UpperCAmelCase_  ).unsqueeze(0  ).to(UpperCAmelCase_  )
  return image


def       lowerCamelCase_       (   UpperCAmelCase_  )						->Optional[Any]:





  """simple docstring"""


  if "visual_encoder" in key:
    __UpperCAmelCase    :						Tuple       =						re.sub('''visual_encoder*'''  ,			'''vision_model.encoder'''  ,			UpperCAmelCase_  )
  if "blocks" in key:
    __UpperCAmelCase    :						List[str]       =						re.sub(R'''blocks'''  ,			'''layers'''  ,			UpperCAmelCase_  )
  if "attn" in key:
    __UpperCAmelCase    :						Union[str, Any]       =						re.sub(R'''attn'''  ,			'''self_attn'''  ,			UpperCAmelCase_  )
  if "norm1" in key:
    __UpperCAmelCase    :						Optional[Any]       =						re.sub(R'''norm1'''  ,			'''layer_norm1'''  ,			UpperCAmelCase_  )
  if "norm2" in key:
    __UpperCAmelCase    :						Optional[int]       =						re.sub(R'''norm2'''  ,			'''layer_norm2'''  ,			UpperCAmelCase_  )
  if "encoder.norm" in key:
    __UpperCAmelCase    :						Union[str, Any]       =						re.sub(R'''encoder.norm'''  ,			'''post_layernorm'''  ,			UpperCAmelCase_  )
  if "encoder.patch_embed.proj" in key:
    __UpperCAmelCase    :						Optional[int]       =						re.sub(R'''encoder.patch_embed.proj'''  ,			'''embeddings.patch_embedding'''  ,			UpperCAmelCase_  )

  if "encoder.pos_embed" in key:
    __UpperCAmelCase    :						List[Any]       =						re.sub(R'''encoder.pos_embed'''  ,			'''embeddings.position_embedding'''  ,			UpperCAmelCase_  )
  if "encoder.cls_token" in key:
    __UpperCAmelCase    :						List[str]       =						re.sub(R'''encoder.cls_token'''  ,			'''embeddings.class_embedding'''  ,			UpperCAmelCase_  )

  if "self_attn" in key:
    __UpperCAmelCase    :						Any       =						re.sub(R'''self_attn.proj'''  ,			'''self_attn.projection'''  ,			UpperCAmelCase_  )

  return key


@torch.no_grad()
def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_=None  )						->Dict:





  """simple docstring"""


  if config_path is not None:
    __UpperCAmelCase    :						Optional[int]       =						BlipConfig.from_pretrained(UpperCAmelCase_  )
  else:
    __UpperCAmelCase    :						Optional[int]       =						BlipConfig(projection_dim=5_12  ,			text_config={}  ,			vision_config={}  )

  __UpperCAmelCase    :						Optional[Any]       =						BlipForConditionalGeneration(UpperCAmelCase_  ).eval()

  __UpperCAmelCase    :						List[str]       =						'''https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_capfilt_large.pth'''

  __UpperCAmelCase    :						List[Any]       =						blip_decoder(pretrained=UpperCAmelCase_  ,			image_size=3_84  ,			vit='''base'''  )
  __UpperCAmelCase    :						str       =						pt_model.eval()

  __UpperCAmelCase    :						List[Any]       =						pt_model.state_dict()
  for key in modified_state_dict.copy():
    __UpperCAmelCase    :						List[str]       =						modified_state_dict.pop(UpperCAmelCase_  )
    __UpperCAmelCase    :						Optional[int]       =						rename_key(UpperCAmelCase_  )
    __UpperCAmelCase    :						List[Any]       =						value

  hf_model.load_state_dict(UpperCAmelCase_  )

  __UpperCAmelCase    :						str       =						3_84
  __UpperCAmelCase    :						Tuple       =						load_demo_image(image_size=UpperCAmelCase_  ,			device='''cpu'''  )
  __UpperCAmelCase    :						Optional[Any]       =						BertTokenizer.from_pretrained('''bert-base-uncased'''  )
  __UpperCAmelCase    :						Optional[int]       =						tokenizer(['''a picture of''']  ).input_ids

  __UpperCAmelCase    :						Union[str, Any]       =						hf_model.generate(UpperCAmelCase_  ,			UpperCAmelCase_  )

  assert out[0].tolist() == [3_05_22, 10_37, 38_61, 19_97, 10_37, 24_50, 35_64, 20_06, 19_96, 35_09, 20_07, 20_14, 38_99, 1_02]

  __UpperCAmelCase    :						Optional[int]       =						hf_model.generate(UpperCAmelCase_  )

  assert out[0].tolist() == [3_05_22, 10_37, 24_50, 35_64, 20_06, 19_96, 35_09, 20_07, 20_14, 38_99, 1_02]

  if pytorch_dump_folder_path is not None:
    hf_model.save_pretrained(UpperCAmelCase_  )

  # model_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_vqa.pth'
  __UpperCAmelCase    :						Optional[Any]       =						(
      '''https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_vqa_capfilt_large.pth'''
  )

  __UpperCAmelCase    :						List[str]       =						blip_vqa(pretrained=UpperCAmelCase_  ,			image_size=UpperCAmelCase_  ,			vit='''base'''  )
  vqa_model.eval()

  __UpperCAmelCase    :						Dict       =						vqa_model.state_dict()
  for key in modified_state_dict.copy():
    __UpperCAmelCase    :						List[Any]       =						modified_state_dict.pop(UpperCAmelCase_  )
    __UpperCAmelCase    :						int       =						rename_key(UpperCAmelCase_  )
    __UpperCAmelCase    :						Union[str, Any]       =						value

  __UpperCAmelCase    :						List[str]       =						BlipForQuestionAnswering(UpperCAmelCase_  )

  hf_vqa_model.load_state_dict(UpperCAmelCase_  )

  __UpperCAmelCase    :						str       =						['''How many dogs are in this image?''']
  __UpperCAmelCase    :						Dict       =						tokenizer(UpperCAmelCase_  ,			return_tensors='''pt'''  ).input_ids

  __UpperCAmelCase    :						Any       =						hf_vqa_model.generate(UpperCAmelCase_  ,			UpperCAmelCase_  )
  print(tokenizer.decode(answer[0]  )  )

  assert tokenizer.decode(answer[0]  ) == "[UNK] 1 [SEP]"
  if pytorch_dump_folder_path is not None:
    hf_vqa_model.save_pretrained(pytorch_dump_folder_path + '''_vqa'''  )

  __UpperCAmelCase    :						List[Any]       =						'''https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_retrieval_coco.pth'''

  __UpperCAmelCase    :						List[str]       =						blip_itm(pretrained=UpperCAmelCase_  ,			image_size=UpperCAmelCase_  ,			vit='''base'''  )
  itm_model.eval()

  __UpperCAmelCase    :						Any       =						itm_model.state_dict()
  for key in modified_state_dict.copy():
    __UpperCAmelCase    :						List[str]       =						modified_state_dict.pop(UpperCAmelCase_  )
    __UpperCAmelCase    :						Dict       =						rename_key(UpperCAmelCase_  )
    __UpperCAmelCase    :						int       =						value

  __UpperCAmelCase    :						Optional[int]       =						BlipForImageTextRetrieval(UpperCAmelCase_  )

  __UpperCAmelCase    :						List[str]       =						['''A picture of a woman with a dog sitting in a beach''']
  __UpperCAmelCase    :						Optional[int]       =						tokenizer(
      UpperCAmelCase_  ,			return_tensors='''pt'''  ,			padding='''max_length'''  ,			truncation=UpperCAmelCase_  ,			max_length=35  ,			).input_ids

  hf_itm_model.load_state_dict(UpperCAmelCase_  )
  hf_itm_model.eval()

  __UpperCAmelCase    :						List[Any]       =						hf_itm_model(UpperCAmelCase_  ,			UpperCAmelCase_  ,			use_itm_head=UpperCAmelCase_  )
  __UpperCAmelCase    :						int       =						hf_itm_model(UpperCAmelCase_  ,			UpperCAmelCase_  ,			use_itm_head=UpperCAmelCase_  )

  assert out[0].item() == 0.2_110_687_494_277_954
  assert torch.nn.functional.softmax(out_itm[0]  ,			dim=1  )[:, 1].item() == 0.45_698_845_386_505_127

  if pytorch_dump_folder_path is not None:
    hf_itm_model.save_pretrained(pytorch_dump_folder_path + '''_itm'''  )


if __name__ == "__main__":
  lowercase__				:str				   =       argparse.ArgumentParser()
  parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
  parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
  lowercase__				:int				   =       parser.parse_args()

  convert_blip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)