






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 				_A			:
    """simple docstring"""

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



    def _a							(				self      :     Union[str, Any]      )      ->							Union[str, Any]:
           __UpperCAmelCase     				=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

           __UpperCAmelCase     				=None
           if self.use_labels:
                  __UpperCAmelCase     				=ids_tensor([self.batch_size] ,     self.num_labels      )

           __UpperCAmelCase     				=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      :     Dict ,     __SCREAMING_SNAKE_CASE      :     Any ,     __SCREAMING_SNAKE_CASE      :     int ,     __SCREAMING_SNAKE_CASE      :     List[str]      )      ->							List[str]:
           __UpperCAmelCase     				=TFResNetModel(config=lowerCAmelCase_      )
           __UpperCAmelCase     				=model(lowerCAmelCase_      )
           # 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      :     Optional[int] ,     __SCREAMING_SNAKE_CASE      :     List[Any] ,     __SCREAMING_SNAKE_CASE      :     Optional[Any] ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]      )      ->							Optional[int]:
           __UpperCAmelCase     				=self.num_labels
           __UpperCAmelCase     				=TFResNetForImageClassification(lowerCAmelCase_      )
           __UpperCAmelCase     				=model(lowerCAmelCase_ ,     labels=lowerCAmelCase_      )
           self.parent.assertEqual(result.logits.shape ,     (self.batch_size, self.num_labels)      )



    def _a							(				self      :     Any      )      ->							Union[str, Any]:
           __UpperCAmelCase     				=self.prepare_config_and_inputs()
           __UpperCAmelCase     				=config_and_inputs
           __UpperCAmelCase     				={"""pixel_values""": pixel_values}
           return config, inputs_dict




@require_tf
class 				_A			(     _SCREAMING_SNAKE_CASE					,					_SCREAMING_SNAKE_CASE					,					unittest.TestCase				):
    """simple docstring"""

    lowerCamelCase	:							Any				= (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
    lowerCamelCase	:							Dict				= (
        {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
        if is_tf_available()
        else {}
    )

    lowerCamelCase	:							int				= False
    lowerCamelCase	:							Optional[Any]				= False
    lowerCamelCase	:							str				= False
    lowerCamelCase	:							List[Any]				= False
    lowerCamelCase	:							Tuple				= False



    def _a							(				self      :     List[Any]      )      ->							int:
           __UpperCAmelCase     				=TFResNetModelTester(self      )
           __UpperCAmelCase     				=ConfigTester(self ,     config_class=lowerCAmelCase_ ,     has_text_modality=lowerCAmelCase_      )



    def _a							(				self      :     List[Any]      )      ->							int:
           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      :     str      )      ->							Any:
           return



    @unittest.skip(reason="""ResNet does not use inputs_embeds"""      )
    def _a							(				self      :     Tuple      )      ->							str:
           pass



    @unittest.skip(reason="""ResNet does not support input and output embeddings"""      )
    def _a							(				self      :     List[str]      )      ->							Tuple:
           pass



    def _a							(				self      :     Optional[Any]      )      ->							Any:
           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs_for_common()

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

                  __UpperCAmelCase     				=["""pixel_values"""]
                  self.assertListEqual(arg_names[:1] ,     lowerCAmelCase_      )



    def _a							(				self      :     Any      )      ->							Optional[Any]:
           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCAmelCase_      )



    def _a							(				self      :     Any      )      ->							int:
           def check_hidden_states_output(__SCREAMING_SNAKE_CASE      :     Optional[Any] ,     __SCREAMING_SNAKE_CASE      :     List[Any] ,     __SCREAMING_SNAKE_CASE      :     Optional[int]      ):
                  __UpperCAmelCase     				=model_class(lowerCAmelCase_      )
                  __UpperCAmelCase     				=model(**self._prepare_for_class(lowerCAmelCase_ ,     lowerCAmelCase_      )      )

                  __UpperCAmelCase     				=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                  __UpperCAmelCase     				=self.model_tester.num_stages
                  self.assertEqual(len(lowerCAmelCase_      ) ,     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] ,     )

           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs_for_common()
           __UpperCAmelCase     				=["""basic""", """bottleneck"""]
           for model_class in self.all_model_classes:
                  for layer_type in layers_type:
                         __UpperCAmelCase     				=layer_type
                         __UpperCAmelCase     				=True
                         check_hidden_states_output(lowerCAmelCase_ ,     lowerCAmelCase_ ,     lowerCAmelCase_      )

                         # check that output_hidden_states also work using config
                         del inputs_dict["output_hidden_states"]
                         __UpperCAmelCase     				=True

                         check_hidden_states_output(lowerCAmelCase_ ,     lowerCAmelCase_ ,     lowerCAmelCase_      )



    def _a							(				self      :     List[Any]      )      ->							Union[str, Any]:
           __UpperCAmelCase     				=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_      )



    @slow
    def _a							(				self      :     int      )      ->							Optional[int]:
           for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  __UpperCAmelCase     				=TFResNetModel.from_pretrained(lowerCAmelCase_      )
                  self.assertIsNotNone(lowerCAmelCase_      )







def       lowercase__	(					)	->				str:







       """simple docstring"""






       __UpperCAmelCase     				=Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
       return image





@require_tf
@require_vision
class 				_A			(     unittest.TestCase				):
    """simple docstring"""

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



    @slow
    def _a							(				self      :     int      )      ->							Any:
           __UpperCAmelCase     				=TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

           __UpperCAmelCase     				=self.default_image_processor
           __UpperCAmelCase     				=prepare_img()
           __UpperCAmelCase     				=image_processor(images=lowerCAmelCase_ ,     return_tensors="""tf"""      )

           # forward pass
           __UpperCAmelCase     				=model(**lowerCAmelCase_      )

           # verify the logits
           __UpperCAmelCase     				=tf.TensorShape((1, 1000)      )
           self.assertEqual(outputs.logits.shape ,     lowerCAmelCase_      )

           __UpperCAmelCase     				=tf.constant([-11.1_069, -9.7_877, -8.3_777]      )

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












"""simple docstring"""
from __future__ import annotations






def       __UpperCamelCase						(		snake_case__ , snake_case__ = None , snake_case__ = None       ):
	if start is None:
		A_		:    Dict						     = 0

	if end is None:
		A_		:    Dict						     = len(snake_case__       ) - 1

	if start >= end:
		return

	A_		:    List[Any]						     = (start + end) // 2

	slowsort(snake_case__ , snake_case__ , snake_case__       )
	slowsort(snake_case__ , mid + 1 , snake_case__       )

	if sequence[end] < sequence[mid]:
		A_     ,  A_		:    Dict						     = sequence[mid], sequence[end]

	slowsort(snake_case__ , snake_case__ , end - 1       )


if __name__ == "__main__":
							from doctest import testmod

							testmod()

