






"""simple docstring"""



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import TFResNetForImageClassification, TFResNetModel
						from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor





class 					_UpperCAmelCase       :




					def __init__(				self     :						int    ,						A     :						Tuple    ,						A     :						int=3    ,						A     :						List[str]=32    ,						A     :						Dict=3    ,						A     :						Any=10    ,						A     :						Dict=[10, 20, 30, 40]    ,						A     :						Optional[Any]=[1, 1, 2, 1]    ,						A     :						Union[str, Any]=True    ,						A     :						Optional[Any]=True    ,						A     :						Any="relu"    ,						A     :						Optional[Any]=3    ,						A     :						Tuple=None    ,						)  ->  Dict:
							lowercase_ : str							       =   parent
							lowercase_ : List[Any]							       =   batch_size
							lowercase_ : Optional[int]							       =   image_size
							lowercase_ : int							       =   num_channels
							lowercase_ : int							       =   embeddings_size
							lowercase_ : str							       =   hidden_sizes
							lowercase_ : List[str]							       =   depths
							lowercase_ : Dict							       =   is_training
							lowercase_ : int							       =   use_labels
							lowercase_ : Any							       =   hidden_act
							lowercase_ : List[Any]							       =   num_labels
							lowercase_ : Tuple							       =   scope
							lowercase_ : Optional[Any]							       =   len(A   )




					def   A  (				self     :						str   )  ->  Tuple:
							lowercase_ : Optional[int]							       =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

							lowercase_ : Union[str, Any]							       =   None
							if self.use_labels:
									lowercase_ : List[str]							       =   ids_tensor([self.batch_size]    ,						self.num_labels   )

							lowercase_ : Optional[int]							       =   self.get_config()

							return config, pixel_values, labels




					def   A  (				self     :						Dict   )  ->  int:
							return ResNetConfig(
							    num_channels=self.num_channels    ,						embeddings_size=self.embeddings_size    ,						hidden_sizes=self.hidden_sizes    ,						depths=self.depths    ,						hidden_act=self.hidden_act    ,						num_labels=self.num_labels    ,						image_size=self.image_size    ,						)




					def   A  (				self     :						str    ,						A     :						Tuple    ,						A     :						str    ,						A     :						str   )  ->  str:
							lowercase_ : str							       =   TFResNetModel(config=A   )
							lowercase_ : Union[str, Any]							       =   model(A   )
							# expected last hidden states: B, C, H // 32, W // 32
							self.parent.assertEqual(
							    result.last_hidden_state.shape    ,						(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,						)




					def   A  (				self     :						Any    ,						A     :						int    ,						A     :						List[Any]    ,						A     :						Optional[Any]   )  ->  Optional[Any]:
							lowercase_ : Tuple							       =   self.num_labels
							lowercase_ : Union[str, Any]							       =   TFResNetForImageClassification(A   )
							lowercase_ : Tuple							       =   model(A    ,						labels=A   )
							self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.num_labels)   )






					def   A  (				self     :						Union[str, Any]   )  ->  Tuple:
							lowercase_ : Tuple							       =   self.prepare_config_and_inputs()
							lowercase_       ,					lowercase_       ,					lowercase_ : Dict							       =   config_and_inputs
							lowercase_ : int							       =   {'''pixel_values''': pixel_values}
							return config, inputs_dict





@require_tf
class 					_UpperCAmelCase       ( _A   ,						_A   ,						unittest.TestCase							):
					SCREAMING_SNAKE_CASE_		:				Union[str, Any]							    =   (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
					SCREAMING_SNAKE_CASE_		:				List[Any]							    =   (
					    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   False
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   False
					SCREAMING_SNAKE_CASE_		:				str							    =   False
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   False
					SCREAMING_SNAKE_CASE_		:				Any							    =   False




					def   A  (				self     :						Union[str, Any]   )  ->  List[Any]:
							lowercase_ : int							       =   TFResNetModelTester(self   )
							lowercase_ : str							       =   ConfigTester(self    ,						config_class=A    ,						has_text_modality=A   )




					def   A  (				self     :						Dict   )  ->  Optional[Any]:
							self.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()




					def   A  (				self     :						Dict   )  ->  List[Any]:
							return




					@unittest.skip(reason='''ResNet does not use inputs_embeds'''   )
					def   A  (				self     :						Any   )  ->  Any:
							pass




					@unittest.skip(reason='''ResNet does not support input and output embeddings'''   )
					def   A  (				self     :						List[str]   )  ->  Optional[Any]:
							pass




					def   A  (				self     :						str   )  ->  Tuple:
							lowercase_       ,					lowercase_ : Optional[Any]							       =   self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									lowercase_ : int							       =   model_class(A   )
									lowercase_ : str							       =   inspect.signature(model.call   )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									lowercase_ : str							       =   [*signature.parameters.keys()]

									lowercase_ : str							       =   ['''pixel_values''']
									self.assertListEqual(arg_names[:1]    ,						A   )




					def   A  (				self     :						List[str]   )  ->  Tuple:
							lowercase_ : Optional[Any]							       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*A   )




					def   A  (				self     :						List[Any]   )  ->  List[str]:
							def check_hidden_states_output(A     :						Union[str, Any]    ,						A     :						int    ,						A     :						List[Any]   ):
									lowercase_ : int							       =   model_class(A   )
									lowercase_ : Optional[Any]							       =   model(**self._prepare_for_class(A    ,						A   )   )

									lowercase_ : Union[str, Any]							       =   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

									lowercase_ : Any							       =   self.model_tester.num_stages
									self.assertEqual(len(A   )    ,						expected_num_stages + 1   )

									# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
									self.assertListEqual(
									    list(hidden_states[0].shape[-2:]   )    ,						[self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,						)

							lowercase_       ,					lowercase_ : List[Any]							       =   self.model_tester.prepare_config_and_inputs_for_common()
							lowercase_ : Union[str, Any]							       =   ['''basic''', '''bottleneck''']
							for model_class in self.all_model_classes:
									for layer_type in layers_type:
											lowercase_ : List[str]							       =   layer_type
											lowercase_ : Tuple							       =   True
											check_hidden_states_output(A    ,						A    ,						A   )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											lowercase_ : Optional[Any]							       =   True

											check_hidden_states_output(A    ,						A    ,						A   )




					def   A  (				self     :						Optional[int]   )  ->  Tuple:
							lowercase_ : Optional[int]							       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*A   )






					@slow
					def   A  (				self     :						List[str]   )  ->  Optional[int]:
							for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowercase_ : Tuple							       =   TFResNetModel.from_pretrained(A   )
									self.assertIsNotNone(A   )



def 						lowercase    (				):
		lowercase_ : List[str]							       =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
		return image






@require_tf
@require_vision
class 					_UpperCAmelCase       ( unittest.TestCase							):




					@cached_property
					def   A  (				self     :						Any   )  ->  Optional[int]:
							return (
							    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
							    if is_vision_available()
							    else None
							)






					@slow
					def   A  (				self     :						Any   )  ->  Optional[int]:
							lowercase_ : Optional[int]							       =   TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )

							lowercase_ : List[Any]							       =   self.default_image_processor
							lowercase_ : Dict							       =   prepare_img()
							lowercase_ : List[str]							       =   image_processor(images=A    ,						return_tensors='''tf'''   )

							# forward pass
							lowercase_ : Tuple							       =   model(**A   )

							# verify the logits
							lowercase_ : Optional[int]							       =   tf.TensorShape((1, 10_00)   )
							self.assertEqual(outputs.logits.shape    ,						A   )

							lowercase_ : Optional[Any]							       =   tf.constant([-11.1069, -9.7877, -8.3777]   )

							self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()    ,						A    ,						atol=1e-4   )   )




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







 """simple docstring"""






 def      UpperCAmelCase							(					self							)  ->					List[Any]:
        _A        =  tempfile.mkdtemp()

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

        _A        =  InstructBlipProcessor(lowerCAmelCase_		,				lowerCAmelCase_		,				lowerCAmelCase_							)

        processor.save_pretrained(self.tmpdirname							)



 def      UpperCAmelCase							(					self		,				**lowerCAmelCase_							)  ->					Any:
        return AutoProcessor.from_pretrained(self.tmpdirname		,				**lowerCAmelCase_							).tokenizer



 def      UpperCAmelCase							(					self		,				**lowerCAmelCase_							)  ->					Dict:
        return AutoProcessor.from_pretrained(self.tmpdirname		,				**lowerCAmelCase_							).image_processor



 def      UpperCAmelCase							(					self		,				**lowerCAmelCase_							)  ->					Union[str, Any]:
        return AutoProcessor.from_pretrained(self.tmpdirname		,				**lowerCAmelCase_							).qformer_tokenizer



 def      UpperCAmelCase							(					self							)  ->					int:
        shutil.rmtree(self.tmpdirname							)



 def      UpperCAmelCase							(					self							)  ->					Union[str, Any]:
        _A        =  [np.random.randint(2_55		,				size=(3, 30, 4_00)		,				dtype=np.uinta							)]

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

        return image_inputs



 def      UpperCAmelCase							(					self							)  ->					str:
        _A        =  InstructBlipProcessor(
            tokenizer=self.get_tokenizer()		,				image_processor=self.get_image_processor()		,				qformer_tokenizer=self.get_qformer_tokenizer()		,				)
        processor.save_pretrained(self.tmpdirname							)

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

        _A        =  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							)  ->					int:
        _A        =  self.get_image_processor()
        _A        =  self.get_tokenizer()
        _A        =  self.get_qformer_tokenizer()

        _A        =  InstructBlipProcessor(
            tokenizer=lowerCAmelCase_		,				image_processor=lowerCAmelCase_		,				qformer_tokenizer=lowerCAmelCase_							)

        _A        =  self.prepare_image_inputs()

        _A        =  image_processor(lowerCAmelCase_		,				return_tensors="""np"""							)
        _A        =  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							)  ->					Dict:
        _A        =  self.get_image_processor()
        _A        =  self.get_tokenizer()
        _A        =  self.get_qformer_tokenizer()

        _A        =  InstructBlipProcessor(
            tokenizer=lowerCAmelCase_		,				image_processor=lowerCAmelCase_		,				qformer_tokenizer=lowerCAmelCase_							)

        _A        =  """lower newer"""

        _A        =  processor(text=lowerCAmelCase_							)

        _A        =  tokenizer(lowerCAmelCase_		,				return_token_type_ids=lowerCAmelCase_							)
        _A        =  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							)  ->					List[str]:
        _A        =  self.get_image_processor()
        _A        =  self.get_tokenizer()
        _A        =  self.get_qformer_tokenizer()

        _A        =  InstructBlipProcessor(
            tokenizer=lowerCAmelCase_		,				image_processor=lowerCAmelCase_		,				qformer_tokenizer=lowerCAmelCase_							)

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

        _A        =  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							)  ->					int:
        _A        =  self.get_image_processor()
        _A        =  self.get_tokenizer()
        _A        =  self.get_qformer_tokenizer()

        _A        =  InstructBlipProcessor(
            tokenizer=lowerCAmelCase_		,				image_processor=lowerCAmelCase_		,				qformer_tokenizer=lowerCAmelCase_							)

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

        _A        =  processor.batch_decode(lowerCAmelCase_							)
        _A        =  tokenizer.batch_decode(lowerCAmelCase_							)

        self.assertListEqual(lowerCAmelCase_		,				lowerCAmelCase_							)



 def      UpperCAmelCase							(					self							)  ->					Optional[Any]:
        _A        =  self.get_image_processor()
        _A        =  self.get_tokenizer()
        _A        =  self.get_qformer_tokenizer()

        _A        =  InstructBlipProcessor(
            tokenizer=lowerCAmelCase_		,				image_processor=lowerCAmelCase_		,				qformer_tokenizer=lowerCAmelCase_							)

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

        _A        =  processor(text=lowerCAmelCase_		,				images=lowerCAmelCase_							)

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




