





import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
    from PIL import Image

    from transformers import (
        AutoProcessor,
        BertTokenizerFast,
        BlipImageProcessor,
        GPTaTokenizer,
        InstructBlipProcessor,
        PreTrainedTokenizerFast,
    )







@require_vision
class __a (   unittest.TestCase			):





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       tempfile.mkdtemp()

      __SCREAMING_SNAKE_CASE      							=       BlipImageProcessor()
      __SCREAMING_SNAKE_CASE      							=       GPTaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-GPT2Model"""    )
      __SCREAMING_SNAKE_CASE      							=       BertTokenizerFast.from_pretrained("""hf-internal-testing/tiny-random-bert"""    )

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(lowerCamelCase				,lowerCamelCase				,lowerCamelCase    )

      processor.save_pretrained(self.tmpdirname    )





   def      UpperCAmelCase__     (					self				:			Optional[Any]				,**lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      return AutoProcessor.from_pretrained(self.tmpdirname				,**lowerCamelCase    ).tokenizer





   def      UpperCAmelCase__     (					self				:			Optional[Any]				,**lowerCamelCase				:			List[Any]    ):

      '''simple docstring'''

      return AutoProcessor.from_pretrained(self.tmpdirname				,**lowerCamelCase    ).image_processor





   def      UpperCAmelCase__     (					self				:			List[Any]				,**lowerCamelCase				:			Dict    ):

      '''simple docstring'''

      return AutoProcessor.from_pretrained(self.tmpdirname				,**lowerCamelCase    ).qformer_tokenizer





   def      UpperCAmelCase__     (					self				:			Dict    ):

      '''simple docstring'''

      shutil.rmtree(self.tmpdirname    )





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       [np.random.randint(255				,size=(3, 30, 400)				,dtype=np.uinta    )]

      __SCREAMING_SNAKE_CASE      							=       [Image.fromarray(np.moveaxis(lowerCamelCase				,0				,-1    )    ) for x in image_inputs]

      return image_inputs





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(
          tokenizer=self.get_tokenizer()				,image_processor=self.get_image_processor()				,qformer_tokenizer=self.get_qformer_tokenizer()				,)
      processor.save_pretrained(self.tmpdirname    )

      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer(bos_token="""(BOS)"""				,eos_token="""(EOS)"""    )
      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor(do_normalize=lowerCamelCase				,padding_value=1.0    )

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor.from_pretrained(
          self.tmpdirname				,bos_token="""(BOS)"""				,eos_token="""(EOS)"""				,do_normalize=lowerCamelCase				,padding_value=1.0    )

      self.assertEqual(processor.tokenizer.get_vocab()				,tokenizer_add_kwargs.get_vocab()    )
      self.assertIsInstance(processor.tokenizer				,lowerCamelCase    )

      self.assertEqual(processor.image_processor.to_json_string()				,image_processor_add_kwargs.to_json_string()    )
      self.assertIsInstance(processor.image_processor				,lowerCamelCase    )
      self.assertIsInstance(processor.qformer_tokenizer				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(
          tokenizer=lowerCamelCase				,image_processor=lowerCamelCase				,qformer_tokenizer=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      							=       image_processor(lowerCamelCase				,return_tensors="""np"""    )
      __SCREAMING_SNAKE_CASE      							=       processor(images=lowerCamelCase				,return_tensors="""np"""    )

      for key in input_feat_extract.keys():
         self.assertAlmostEqual(input_feat_extract[key].sum()				,input_processor[key].sum()				,delta=1E-2    )





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(
          tokenizer=lowerCamelCase				,image_processor=lowerCamelCase				,qformer_tokenizer=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       """lower newer"""

      __SCREAMING_SNAKE_CASE      							=       processor(text=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       tokenizer(lowerCamelCase				,return_token_type_ids=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       qformer_tokenizer(lowerCamelCase				,return_token_type_ids=lowerCamelCase    )

      for key in encoded_tokens.keys():
         self.assertListEqual(encoded_tokens[key]				,encoded_processor[key]    )

      for key in encoded_tokens_qformer.keys():
         self.assertListEqual(encoded_tokens_qformer[key]				,encoded_processor["""qformer_""" + key]    )





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(
          tokenizer=lowerCamelCase				,image_processor=lowerCamelCase				,qformer_tokenizer=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       """lower newer"""
      __SCREAMING_SNAKE_CASE      							=       self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      							=       processor(text=lowerCamelCase				,images=lowerCamelCase    )

      self.assertListEqual(
          list(inputs.keys()    )				,["""input_ids""", """attention_mask""", """qformer_input_ids""", """qformer_attention_mask""", """pixel_values"""]				,)

      # test if it raises when no input is passed
      with pytest.raises(lowerCamelCase    ):
         processor()





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(
          tokenizer=lowerCamelCase				,image_processor=lowerCamelCase				,qformer_tokenizer=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       tokenizer.batch_decode(lowerCamelCase    )

      self.assertListEqual(lowerCamelCase				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_qformer_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       InstructBlipProcessor(
          tokenizer=lowerCamelCase				,image_processor=lowerCamelCase				,qformer_tokenizer=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       """lower newer"""
      __SCREAMING_SNAKE_CASE      							=       self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      							=       processor(text=lowerCamelCase				,images=lowerCamelCase    )

      self.assertListEqual(
          list(inputs.keys()    )				,["""input_ids""", """attention_mask""", """qformer_input_ids""", """qformer_attention_mask""", """pixel_values"""]				,)












'''simple docstring'''

import inspect
import unittest

import numpy as np

from transformers import ViTConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
    import jax

    from transformers.models.vit.modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel







class __a (   unittest.TestCase			):





   def __init__(					self				:			Optional[int]				,lowerCamelCase				:			str				,lowerCamelCase				:			List[str]=13				,lowerCamelCase				:			Optional[Any]=30				,lowerCamelCase				:			Dict=2				,lowerCamelCase				:			List[Any]=3				,lowerCamelCase				:			List[str]=True				,lowerCamelCase				:			str=True				,lowerCamelCase				:			Optional[int]=32				,lowerCamelCase				:			Dict=5				,lowerCamelCase				:			Optional[int]=4				,lowerCamelCase				:			List[Any]=37				,lowerCamelCase				:			Union[str, Any]="gelu"				,lowerCamelCase				:			List[Any]=0.1				,lowerCamelCase				:			Any=0.1				,lowerCamelCase				:			str=10				,lowerCamelCase				:			Dict=0.02				,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       parent
      __SCREAMING_SNAKE_CASE      							=       batch_size
      __SCREAMING_SNAKE_CASE      							=       image_size
      __SCREAMING_SNAKE_CASE      							=       patch_size
      __SCREAMING_SNAKE_CASE      							=       num_channels
      __SCREAMING_SNAKE_CASE      							=       is_training
      __SCREAMING_SNAKE_CASE      							=       use_labels
      __SCREAMING_SNAKE_CASE      							=       hidden_size
      __SCREAMING_SNAKE_CASE      							=       num_hidden_layers
      __SCREAMING_SNAKE_CASE      							=       num_attention_heads
      __SCREAMING_SNAKE_CASE      							=       intermediate_size
      __SCREAMING_SNAKE_CASE      							=       hidden_act
      __SCREAMING_SNAKE_CASE      							=       hidden_dropout_prob
      __SCREAMING_SNAKE_CASE      							=       attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE      							=       type_sequence_label_size
      __SCREAMING_SNAKE_CASE      							=       initializer_range

      # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
      __SCREAMING_SNAKE_CASE      							=       (image_size // patch_size) ** 2
      __SCREAMING_SNAKE_CASE      							=       num_patches + 1





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

      __SCREAMING_SNAKE_CASE      							=       ViTConfig(
          image_size=self.image_size				,patch_size=self.patch_size				,num_channels=self.num_channels				,hidden_size=self.hidden_size				,num_hidden_layers=self.num_hidden_layers				,num_attention_heads=self.num_attention_heads				,intermediate_size=self.intermediate_size				,hidden_act=self.hidden_act				,hidden_dropout_prob=self.hidden_dropout_prob				,attention_probs_dropout_prob=self.attention_probs_dropout_prob				,is_decoder=lowerCamelCase				,initializer_range=self.initializer_range				,)

      return config, pixel_values





   def      UpperCAmelCase__     (					self				:			Tuple				,lowerCamelCase				:			int				,lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       FlaxViTModel(config=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )
      # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token)
      __SCREAMING_SNAKE_CASE      							=       (self.image_size, self.image_size)
      __SCREAMING_SNAKE_CASE      							=       (self.patch_size, self.patch_size)
      __SCREAMING_SNAKE_CASE      							=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
      self.parent.assertEqual(result.last_hidden_state.shape				,(self.batch_size, num_patches + 1, self.hidden_size)    )





   def      UpperCAmelCase__     (					self				:			Union[str, Any]				,lowerCamelCase				:			Optional[int]				,lowerCamelCase				:			Dict    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.type_sequence_label_size
      __SCREAMING_SNAKE_CASE      							=       FlaxViTForImageClassification(config=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )
      self.parent.assertEqual(result.logits.shape				,(self.batch_size, self.type_sequence_label_size)    )

      # test greyscale images
      __SCREAMING_SNAKE_CASE      							=       1
      __SCREAMING_SNAKE_CASE      							=       FlaxViTForImageClassification(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
      __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.prepare_config_and_inputs()
      (
          (
          __SCREAMING_SNAKE_CASE
      )							,     (
          __SCREAMING_SNAKE_CASE
      )							,     
      )      							=       config_and_inputs
      __SCREAMING_SNAKE_CASE      							=       {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_flax
class __a (   _snake_case,   unittest.TestCase			):
   __UpperCamelCase   : Any	      =	(FlaxViTModel, FlaxViTForImageClassification) if is_flax_available() else ()





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       FlaxViTModelTester(self    )
      __SCREAMING_SNAKE_CASE      							=       ConfigTester(self				,config_class=lowerCamelCase				,has_text_modality=lowerCamelCase				,hidden_size=37    )





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      self.config_tester.run_common_tests()





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )
         __SCREAMING_SNAKE_CASE      							=       inspect.signature(model.__call__    )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __SCREAMING_SNAKE_CASE      							=       [*signature.parameters.keys()]

         __SCREAMING_SNAKE_CASE      							=       ["""pixel_values"""]
         self.assertListEqual(arg_names[:1]				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         with self.subTest(model_class.__name__    ):
            __SCREAMING_SNAKE_CASE      							=       self._prepare_for_class(lowerCamelCase				,lowerCamelCase    )
            __SCREAMING_SNAKE_CASE      							=       model_class(lowerCamelCase    )

            @jax.jit
            def model_jitted(lowerCamelCase				:			int				,**lowerCamelCase				:			Union[str, Any]    ):
               return model(pixel_values=lowerCamelCase				,**lowerCamelCase    )

            with self.subTest("""JIT Enabled"""    ):
               __SCREAMING_SNAKE_CASE      							=       model_jitted(**lowerCamelCase    ).to_tuple()

            with self.subTest("""JIT Disabled"""    ):
               with jax.disable_jit():
                  __SCREAMING_SNAKE_CASE      							=       model_jitted(**lowerCamelCase    ).to_tuple()

            self.assertEqual(len(lowerCamelCase    )				,len(lowerCamelCase    )    )
            for jitted_output, output in zip(lowerCamelCase				,lowerCamelCase    ):
               self.assertEqual(jitted_output.shape				,output.shape    )





   @slow
   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      for model_class_name in self.all_model_classes:
         __SCREAMING_SNAKE_CASE      							=       model_class_name.from_pretrained("""google/vit-base-patch16-224"""    )
         __SCREAMING_SNAKE_CASE      							=       model(np.ones((1, 3, 224, 224)    )    )
         self.assertIsNotNone(lowerCamelCase    )





