


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 			SCREAMING_SNAKE_CASE__  :
      def __init__(	self    :	List[str]					,							SCREAMING_SNAKE_CASE__    :	Optional[int]					,							SCREAMING_SNAKE_CASE__    :	int=3					,							SCREAMING_SNAKE_CASE__    :	List[Any]=3_2					,							SCREAMING_SNAKE_CASE__    :	List[str]=3					,							SCREAMING_SNAKE_CASE__    :	Union[str, Any]=1_0					,							SCREAMING_SNAKE_CASE__    :	str=[1_0, 2_0, 3_0, 4_0]					,							SCREAMING_SNAKE_CASE__    :	Dict=[1, 1, 2, 1]					,							SCREAMING_SNAKE_CASE__    :	str=True					,							SCREAMING_SNAKE_CASE__    :	Union[str, Any]=True					,							SCREAMING_SNAKE_CASE__    :	Optional[Any]="relu"					,							SCREAMING_SNAKE_CASE__    :	int=3					,							SCREAMING_SNAKE_CASE__    :	List[str]=None					,							)		->      Dict:
             a_ :		Dict							=  parent
             a_ :		List[Any]							=  batch_size
             a_ :		Dict							=  image_size
             a_ :		Dict							=  num_channels
             a_ :		Any							=  embeddings_size
             a_ :		Dict							=  hidden_sizes
             a_ :		Tuple							=  depths
             a_ :		List[Any]							=  is_training
             a_ :		Any							=  use_labels
             a_ :		int							=  hidden_act
             a_ :		int							=  num_labels
             a_ :		str							=  scope
             a_ :		List[Any]							=  len(SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      Optional[int]:
             a_ :		int							=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

             a_ :		Optional[int]							=  None
             if self.use_labels:
                    a_ :		Any							=  ids_tensor([self.batch_size]					,							self.num_labels					)

             a_ :		List[Any]							=  self.get_config()

             return config, pixel_values, labels
      def 	SCREAMING_SNAKE_CASE							(	self    :	List[Any]					)		->      str:
             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 	SCREAMING_SNAKE_CASE							(	self    :	str					,							SCREAMING_SNAKE_CASE__    :	Optional[int]					,							SCREAMING_SNAKE_CASE__    :	int					,							SCREAMING_SNAKE_CASE__    :	List[str]					)		->      Tuple:
             a_ :		int							=  TFResNetModel(config=SCREAMING_SNAKE_CASE__					)
             a_ :		List[str]							=  model(SCREAMING_SNAKE_CASE__					)
             # 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 // 3_2, self.image_size // 3_2)					,							)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					,							SCREAMING_SNAKE_CASE__    :	List[str]					,							SCREAMING_SNAKE_CASE__    :	Union[str, Any]					,							SCREAMING_SNAKE_CASE__    :	List[Any]					)		->      Optional[int]:
             a_ :		List[Any]							=  self.num_labels
             a_ :		Optional[int]							=  TFResNetForImageClassification(SCREAMING_SNAKE_CASE__					)
             a_ :		List[Any]							=  model(SCREAMING_SNAKE_CASE__					,							labels=SCREAMING_SNAKE_CASE__					)
             self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.num_labels)					)

      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					)		->      Optional[Any]:
             a_ :		Union[str, Any]							=  self.prepare_config_and_inputs()
             a_							,		a_							,		a_ :		Optional[Any]							=  config_and_inputs
             a_ :		int							=  {'pixel_values': pixel_values}
             return config, inputs_dict
@require_tf
class 			SCREAMING_SNAKE_CASE__  (    lowercase__						,   lowercase__						,   unittest.TestCase      ):
      snake_case__    :					List[str]					       =						(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
      snake_case__    :					Any					       =						(
          {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification}
          if is_tf_available()
          else {}
      )

      snake_case__    :					Optional[int]					       =						False
      snake_case__    :					str					       =						False
      snake_case__    :					Optional[int]					       =						False
      snake_case__    :					Optional[int]					       =						False
      snake_case__    :					Optional[int]					       =						False
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					)		->      Dict:
             a_ :		Tuple							=  TFResNetModelTester(self					)
             a_ :		Optional[Any]							=  ConfigTester(self					,							config_class=SCREAMING_SNAKE_CASE__					,							has_text_modality=SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Tuple					)		->      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 	SCREAMING_SNAKE_CASE							(	self    :	str					)		->      Any:
             return
      @unittest.skip(reason='ResNet does not use inputs_embeds'					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					)		->      Optional[int]:
             pass
      @unittest.skip(reason='ResNet does not support input and output embeddings'					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	str					)		->      str:
             pass
      def 	SCREAMING_SNAKE_CASE							(	self    :	List[str]					)		->      List[Any]:
             a_							,		a_ :		str							=  self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                    a_ :		Tuple							=  model_class(SCREAMING_SNAKE_CASE__					)
                    a_ :		int							=  inspect.signature(model.call					)
                    # signature.parameters is an OrderedDict => so arg_names order is deterministic
                    a_ :		Union[str, Any]							=  [*signature.parameters.keys()]

                    a_ :		Dict							=  ['pixel_values']
                    self.assertListEqual(arg_names[:1]					,							SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Union[str, Any]					)		->      Dict:
             a_ :		Dict							=  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	int					)		->      List[str]:
             def check_hidden_states_output(SCREAMING_SNAKE_CASE__    :	int					,							SCREAMING_SNAKE_CASE__    :	Optional[Any]					,							SCREAMING_SNAKE_CASE__    :	int					):
                    a_ :		int							=  model_class(SCREAMING_SNAKE_CASE__					)
                    a_ :		Any							=  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)					)

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

                    a_ :		Tuple							=  self.model_tester.num_stages
                    self.assertEqual(len(SCREAMING_SNAKE_CASE__					)					,							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]					,							)

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

                           # check that output_hidden_states also work using config
                           del inputs_dict["output_hidden_states"]
                           a_ :		int							=  True

                           check_hidden_states_output(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	List[Any]					)		->      Union[str, Any]:
             a_ :		Tuple							=  self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__					)

      @slow
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      Tuple:
             for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    a_ :		List[Any]							=  TFResNetModel.from_pretrained(SCREAMING_SNAKE_CASE__					)
                    self.assertIsNotNone(SCREAMING_SNAKE_CASE__					)







def 	SCREAMING_SNAKE_CASE_						(      )     ->		List[str]:

       """simple docstring"""

       a_ :		List[str]							=  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
       return image
@require_tf
@require_vision
class 			SCREAMING_SNAKE_CASE__  (    unittest.TestCase      ):
      @cached_property
      def 	SCREAMING_SNAKE_CASE							(	self    :	Tuple					)		->      int:
             return (
                 AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
                 if is_vision_available()
                 else None
             )

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

             a_ :		str							=  self.default_image_processor
             a_ :		Optional[Any]							=  prepare_img()
             a_ :		str							=  image_processor(images=SCREAMING_SNAKE_CASE__					,							return_tensors='tf'					)

             # forward pass
             a_ :		List[str]							=  model(**SCREAMING_SNAKE_CASE__					)

             # verify the logits
             a_ :		Optional[int]							=  tf.TensorShape((1, 1_0_0_0)					)
             self.assertEqual(outputs.logits.shape					,							SCREAMING_SNAKE_CASE__					)

             a_ :		List[Any]							=  tf.constant([-11.1069, -9.7877, -8.3777]					)

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






def 	SCREAMING_SNAKE_CASE_						(      __A			:      list    )     ->		bool:

       """simple docstring"""

       if not isinstance(__A  ,   __A    ):
              raise ValueError('Input series is not valid, valid series - [2, 4, 6]'    )
       if len(__A    ) == 0:
              raise ValueError('Input list must be a non empty list'    )
       if len(__A    ) == 1:
              return True
       a_ :		Tuple							=  series[1] - series[0]
       for index in range(len(__A    ) - 1    ):
              if series[index + 1] - series[index] != common_diff:
                     return False
       return True







def 	SCREAMING_SNAKE_CASE_						(      __A			:      list    )     ->		float:

       """simple docstring"""

       if not isinstance(__A  ,   __A    ):
              raise ValueError('Input series is not valid, valid series - [2, 4, 6]'    )
       if len(__A    ) == 0:
              raise ValueError('Input list must be a non empty list'    )
       a_ :		str							=  0
       for val in series:
              answer += val
       return answer / len(__A    )


if __name__ == "__main__":
   import doctest

   doctest.testmod()


