





import inspect
import unittest

from transformers import ResNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

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


if is_flax_available():
						import jax
						import jax.numpy as jnp

						from transformers.models.resnet.modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor
class SCREAMING_SNAKE_CASE_    (       unittest.TestCase       ):






						def __init__(   self   :   List[str]		, _A   :   Dict		, _A   :   List[str]=3		, _A   :   Optional[int]=32		, _A   :   Dict=3		, _A   :   Union[str, Any]=10		, _A   :   List[Any]=[10, 20, 30, 40]		, _A   :   int=[1, 1, 2, 1]		, _A   :   List[str]=True		, _A   :   Union[str, Any]=True		, _A   :   str="relu"		, _A   :   Optional[int]=3		, _A   :   List[str]=None		, )				->     Optional[Any]:







							"""simple docstring"""


							snake_case_		:      int           =						parent
							snake_case_		:      Optional[int]           =						batch_size
							snake_case_		:      List[Any]           =						image_size
							snake_case_		:      List[Any]           =						num_channels
							snake_case_		:      Optional[int]           =						embeddings_size
							snake_case_		:      List[str]           =						hidden_sizes
							snake_case_		:      str           =						depths
							snake_case_		:      Tuple           =						is_training
							snake_case_		:      str           =						use_labels
							snake_case_		:      Union[str, Any]           =						hidden_act
							snake_case_		:      Dict           =						num_labels
							snake_case_		:      Tuple           =						scope
							snake_case_		:      List[str]           =						len(_A						)






						def UpperCAmelCase_					(   self   :   Dict						)				->     Union[str, Any]:







							"""simple docstring"""


							snake_case_		:      Dict           =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

							snake_case_		:      str           =						self.get_config()

							return config, pixel_values






						def UpperCAmelCase_					(   self   :   Any						)				->     int:







							"""simple docstring"""


							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 UpperCAmelCase_					(   self   :   str		, _A   :   Union[str, Any]		, _A   :   Optional[int]						)				->     List[Any]:







							"""simple docstring"""


							snake_case_		:      Optional[int]           =						FlaxResNetModel(config=_A						)
							snake_case_		:      Dict           =						model(_A						)

							# Output shape (b, c, h, w)
							self.parent.assertEqual(
							    result.last_hidden_state.shape		, (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		, )






						def UpperCAmelCase_					(   self   :   Dict		, _A   :   Dict		, _A   :   str						)				->     Union[str, Any]:







							"""simple docstring"""


							snake_case_		:      Optional[int]           =						self.num_labels
							snake_case_		:      Tuple           =						FlaxResNetForImageClassification(config=_A						)
							snake_case_		:      Tuple           =						model(_A						)
							self.parent.assertEqual(result.logits.shape		, (self.batch_size, self.num_labels)						)






						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     Union[str, Any]:







							"""simple docstring"""


							snake_case_		:      str           =						self.prepare_config_and_inputs()
							snake_case_    ,snake_case_		:      Tuple           =						config_and_inputs
							snake_case_		:      str           =						{'pixel_values': pixel_values}
							return config, inputs_dict
@require_flax
class SCREAMING_SNAKE_CASE_    (       snake_case_							,					unittest.TestCase       ):
						__magic_name__:      Dict			   =							(FlaxResNetModel, FlaxResNetForImageClassification) if is_flax_available() else ()

						__magic_name__:      Union[str, Any]			   =							False
						__magic_name__:      List[str]			   =							False
						__magic_name__:      Union[str, Any]			   =							False






						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     None:







							"""simple docstring"""


							snake_case_		:      List[Any]           =						FlaxResNetModelTester(self						)
							snake_case_		:      Optional[Any]           =						ConfigTester(self		, config_class=_A		, has_text_modality=_A						)






						def UpperCAmelCase_					(   self   :   Optional[Any]						)				->     str:







							"""simple docstring"""


							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 UpperCAmelCase_					(   self   :   Any						)				->     List[Any]:







							"""simple docstring"""


							return






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







							"""simple docstring"""


							snake_case_		:      List[Any]           =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_A						)






						def UpperCAmelCase_					(   self   :   Dict						)				->     Any:







							"""simple docstring"""


							snake_case_		:      List[Any]           =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_A						)






						@unittest.skip(reason='ResNet does not use inputs_embeds'						)
						def UpperCAmelCase_					(   self   :   Optional[Any]						)				->     Optional[Any]:







							"""simple docstring"""


							pass






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







							"""simple docstring"""


							pass






						def UpperCAmelCase_					(   self   :   List[str]						)				->     Optional[Any]:







							"""simple docstring"""


							snake_case_    ,snake_case_		:      int           =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_		:      Dict           =						model_class(_A						)
								snake_case_		:      List[str]           =						inspect.signature(model.__call__						)
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								snake_case_		:      Optional[Any]           =						[*signature.parameters.keys()]

								snake_case_		:      str           =						['pixel_values']
								self.assertListEqual(arg_names[:1]		, _A						)






						def UpperCAmelCase_					(   self   :   Optional[int]						)				->     int:







							"""simple docstring"""


							def check_hidden_states_output(_A   :   List[str]		, _A   :   List[str]		, _A   :   Union[str, Any]						):
								snake_case_		:      List[str]           =						model_class(_A						)

								snake_case_		:      int           =						model(**self._prepare_for_class(_A		, _A						)						)

								snake_case_		:      Optional[Any]           =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

								snake_case_		:      Any           =						self.model_tester.num_stages
								self.assertEqual(len(_A						)		, expected_num_stages + 1						)






						@unittest.skip(reason='ResNet does not use feedforward chunking'						)
						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     List[str]:







							"""simple docstring"""


							pass






						def UpperCAmelCase_					(   self   :   Tuple						)				->     str:







							"""simple docstring"""


							snake_case_    ,snake_case_		:      Any           =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								with self.subTest(model_class.__name__						):
									snake_case_		:      Union[str, Any]           =						self._prepare_for_class(_A		, _A						)
									snake_case_		:      Any           =						model_class(_A						)

									@jax.jit
									def model_jitted(_A   :   Optional[int]		, **_A   :   List[str]						):
										return model(pixel_values=_A		, **_A						)

									with self.subTest('JIT Enabled'						):
										snake_case_		:      Optional[Any]           =						model_jitted(**_A						).to_tuple()

									with self.subTest('JIT Disabled'						):
										with jax.disable_jit():
											snake_case_		:      Any           =						model_jitted(**_A						).to_tuple()

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


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


@require_flax
class SCREAMING_SNAKE_CASE_    (       unittest.TestCase       ):






						@cached_property
						def UpperCAmelCase_					(   self   :   str						)				->     str:







							"""simple docstring"""


							return AutoImageProcessor.from_pretrained('microsoft/resnet-50'						) if is_vision_available() else None






						@slow
						def UpperCAmelCase_					(   self   :   List[str]						)				->     List[str]:







							"""simple docstring"""


							snake_case_		:      List[Any]           =						FlaxResNetForImageClassification.from_pretrained('microsoft/resnet-50'						)

							snake_case_		:      Optional[int]           =						self.default_image_processor
							snake_case_		:      int           =						prepare_img()
							snake_case_		:      Optional[int]           =						image_processor(images=_A		, return_tensors='np'						)

							snake_case_		:      Any           =						model(**_A						)

							# verify the logits
							snake_case_		:      Any           =						(1, 1000)
							self.assertEqual(outputs.logits.shape		, _A						)

							snake_case_		:      List[str]           =						jnp.array([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]						)

							self.assertTrue(jnp.allclose(outputs.logits[0, :3]		, _A		, atol=1E-4						)						)




"""simple docstring"""





import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import OwlViTImageProcessor




class    _lowerCAmelCase    (      unittest.TestCase  ):







 """simple docstring"""







 def __init__(     self				:     Union[str, Any],   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     Optional[int]=7,   UpperCAmelCase__				:     List[str]=3,   UpperCAmelCase__				:     List[Any]=1_8,   UpperCAmelCase__				:     Any=3_0,   UpperCAmelCase__				:     str=4_0_0,   UpperCAmelCase__				:     Union[str, Any]=True,   UpperCAmelCase__				:     Dict=None,   UpperCAmelCase__				:     int=True,   UpperCAmelCase__				:     str=None,   UpperCAmelCase__				:     Dict=True,   UpperCAmelCase__				:     str=[0.48_145_466, 0.4_578_275, 0.40_821_073],   UpperCAmelCase__				:     Dict=[0.26_862_954, 0.26_130_258, 0.27_577_711],   UpperCAmelCase__				:     Any=True,   ):
    __lowercase								=		parent
    __lowercase								=		batch_size
    __lowercase								=		num_channels
    __lowercase								=		image_size
    __lowercase								=		min_resolution
    __lowercase								=		max_resolution
    __lowercase								=		do_resize
    __lowercase								=		size if size is not None else {"height": 1_8, "width": 1_8}
    __lowercase								=		do_center_crop
    __lowercase								=		crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
    __lowercase								=		do_normalize
    __lowercase								=		image_mean
    __lowercase								=		image_std
    __lowercase								=		do_convert_rgb



 def    _lowercase					(     self				:     List[str]      ):
    return {
        "do_resize": self.do_resize,
        "size": self.size,
        "do_center_crop": self.do_center_crop,
        "crop_size": self.crop_size,
        "do_normalize": self.do_normalize,
        "image_mean": self.image_mean,
        "image_std": self.image_std,
        "do_convert_rgb": self.do_convert_rgb,
    }







@require_torch
@require_vision
class    _lowerCAmelCase    (      lowercase	,unittest.TestCase  ):







 """simple docstring"""







 __UpperCAmelCase      :   List[str]  						=      OwlViTImageProcessor if is_vision_available() else None


 def    _lowercase					(     self				:     Dict      ):
    __lowercase								=		OwlViTImageProcessingTester(self      )


 @property
 def    _lowercase					(     self				:     int      ):
    return self.image_processor_tester.prepare_image_processor_dict()


 def    _lowercase					(     self				:     Tuple      ):
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_resize"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "size"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_center_crop"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "center_crop"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_normalize"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "image_mean"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "image_std"      )      )
    self.assertTrue(hasattr(UpperCAmelCase__,   "do_convert_rgb"      )      )


 def    _lowercase					(     self				:     Dict      ):
    __lowercase								=		self.image_processing_class.from_dict(self.image_processor_dict      )
    self.assertEqual(image_processor.size,   {"height": 1_8, "width": 1_8}      )
    self.assertEqual(image_processor.crop_size,   {"height": 1_8, "width": 1_8}      )

    __lowercase								=		self.image_processing_class.from_dict(self.image_processor_dict,   size=4_2,   crop_size=8_4      )
    self.assertEqual(image_processor.size,   {"height": 4_2, "width": 4_2}      )
    self.assertEqual(image_processor.crop_size,   {"height": 8_4, "width": 8_4}      )


 def    _lowercase					(     self				:     Any      ):
    # Initialize image_processing
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    # create random PIL images
    __lowercase								=		prepare_image_inputs(self.image_processor_tester,   equal_resolution=UpperCAmelCase__      )

    for image in image_inputs:
       self.assertIsInstance(UpperCAmelCase__,   Image.Image      )

    # Test not batched input
    __lowercase								=		image_processing(image_inputs[0],   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )

    # Test batched
    __lowercase								=		image_processing(UpperCAmelCase__,   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )


 def    _lowercase					(     self				:     Optional[Any]      ):
    # Initialize image_processing
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    # create random numpy tensors
    __lowercase								=		prepare_image_inputs(self.image_processor_tester,   equal_resolution=UpperCAmelCase__,   numpify=UpperCAmelCase__      )
    for image in image_inputs:
       self.assertIsInstance(UpperCAmelCase__,   np.ndarray      )

    # Test not batched input
    __lowercase								=		image_processing(image_inputs[0],   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )

    # Test batched
    __lowercase								=		image_processing(UpperCAmelCase__,   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )



 def    _lowercase					(     self				:     List[str]      ):
    # Initialize image_processing
    __lowercase								=		self.image_processing_class(**self.image_processor_dict      )
    # create random PyTorch tensors
    __lowercase								=		prepare_image_inputs(self.image_processor_tester,   equal_resolution=UpperCAmelCase__,   torchify=UpperCAmelCase__      )
    for image in image_inputs:
       self.assertIsInstance(UpperCAmelCase__,   torch.Tensor      )

    # Test not batched input
    __lowercase								=		image_processing(image_inputs[0],   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            1,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )

    # Test batched
    __lowercase								=		image_processing(UpperCAmelCase__,   return_tensors="pt"      ).pixel_values
    self.assertEqual(
        encoded_images.shape,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size["height"],
            self.image_processor_tester.crop_size["width"],
        ),   )




