





"""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 __magic_name__   :
       def __init__(     self   ,  __magic_name__   ,  __magic_name__=3   ,  __magic_name__=3_2   ,  __magic_name__=3   ,  __magic_name__=1_0   ,  __magic_name__=[1_0, 2_0, 3_0, 4_0]   ,  __magic_name__=[1, 1, 2, 1]   ,  __magic_name__=True   ,  __magic_name__=True   ,  __magic_name__="relu"   ,  __magic_name__=3   ,  __magic_name__=None   ,  ):





         """simple docstring"""


         _lowerCAmelCase	      =					parent
         _lowerCAmelCase	      =					batch_size
         _lowerCAmelCase	      =					image_size
         _lowerCAmelCase	      =					num_channels
         _lowerCAmelCase	      =					embeddings_size
         _lowerCAmelCase	      =					hidden_sizes
         _lowerCAmelCase	      =					depths
         _lowerCAmelCase	      =					is_training
         _lowerCAmelCase	      =					use_labels
         _lowerCAmelCase	      =					hidden_act
         _lowerCAmelCase	      =					num_labels
         _lowerCAmelCase	      =					scope
         _lowerCAmelCase	      =					len(__lowerCAmelCase	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


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

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

         _lowerCAmelCase	      =					self.get_config()

         return config, pixel_values, labels
       def 		_lowerCamelCase   (     self	):





         """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 		_lowerCamelCase   (     self   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__	):





         """simple docstring"""


         _lowerCAmelCase	      =					TFResNetModel(config=__lowerCAmelCase	)
         _lowerCAmelCase	      =					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 // 3_2, self.image_size // 3_2)   ,  )
       def 		_lowerCamelCase   (     self   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__	):





         """simple docstring"""


         _lowerCAmelCase	      =					self.num_labels
         _lowerCAmelCase	      =					TFResNetForImageClassification(__lowerCAmelCase	)
         _lowerCAmelCase	      =					model(__lowerCAmelCase   ,  labels=__lowerCAmelCase	)
         self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.num_labels)	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         _lowerCAmelCase	      =					self.prepare_config_and_inputs()
         _lowerCAmelCase	      =					config_and_inputs
         _lowerCAmelCase	      =					{'''pixel_values''': pixel_values}
         return config, inputs_dict





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

       UpperCamelCase    :						Any      =	False
       UpperCamelCase    :						str      =	False
       UpperCamelCase    :						Union[str, Any]      =	False
       UpperCamelCase    :						int      =	False
       UpperCamelCase    :						str      =	False
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         _lowerCAmelCase	      =					TFResNetModelTester(self	)
         _lowerCAmelCase	      =					ConfigTester(self   ,  config_class=__lowerCAmelCase   ,  has_text_modality=__lowerCAmelCase	)
       def 		_lowerCamelCase   (     self	):





         """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 		_lowerCamelCase   (     self	):





         """simple docstring"""


         return
       @unittest.skip(reason='ResNet does not use inputs_embeds'	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         pass
       @unittest.skip(reason='ResNet does not support input and output embeddings'	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         pass
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         _lowerCAmelCase	      =					self.model_tester.prepare_config_and_inputs_for_common()

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

           _lowerCAmelCase	      =					['''pixel_values''']
           self.assertListEqual(arg_names[:1]   ,  __lowerCAmelCase	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         _lowerCAmelCase	      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCAmelCase	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         def check_hidden_states_output(__magic_name__   ,  __magic_name__   ,  __magic_name__	):
           _lowerCAmelCase	      =					model_class(__lowerCAmelCase	)
           _lowerCAmelCase	      =					model(**self._prepare_for_class(__lowerCAmelCase   ,  __lowerCAmelCase	)	)

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

           _lowerCAmelCase	      =					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]   ,  )

         _lowerCAmelCase	      =					self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCAmelCase	      =					['''basic''', '''bottleneck''']
         for model_class in self.all_model_classes:
           for layer_type in layers_type:
             _lowerCAmelCase	      =					layer_type
             _lowerCAmelCase	      =					True
             check_hidden_states_output(__lowerCAmelCase   ,  __lowerCAmelCase   ,  __lowerCAmelCase	)

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

             check_hidden_states_output(__lowerCAmelCase   ,  __lowerCAmelCase   ,  __lowerCAmelCase	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         _lowerCAmelCase	      =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase	)
       @slow
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase	      =					TFResNetModel.from_pretrained(__lowerCAmelCase	)
           self.assertIsNotNone(__lowerCAmelCase	)







def     A__			(       ):





  """simple docstring"""
  _lowerCAmelCase	      =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
  return image




@require_tf
@require_vision
class __magic_name__   (       unittest.TestCase		):
       @cached_property
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         return (
             AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
             if is_vision_available()
             else None
         )
       @slow
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         _lowerCAmelCase	      =					TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)

         _lowerCAmelCase	      =					self.default_image_processor
         _lowerCAmelCase	      =					prepare_img()
         _lowerCAmelCase	      =					image_processor(images=__lowerCAmelCase   ,  return_tensors='tf'	)

         # forward pass
         _lowerCAmelCase	      =					model(**__lowerCAmelCase	)

         # verify the logits
         _lowerCAmelCase	      =					tf.TensorShape((1, 1_0_0_0)	)
         self.assertEqual(outputs.logits.shape   ,  __lowerCAmelCase	)

         _lowerCAmelCase	      =					tf.constant([-11.10_69, -9.78_77, -8.37_77]	)

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











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


SCREAMING_SNAKE_CASE__   :      Dict				=		{
    """configuration_canine""": ["""CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CanineConfig"""],
    """tokenization_canine""": ["""CanineTokenizer"""],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__   :      str				=		[
					    """CANINE_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """CanineForMultipleChoice""",
					    """CanineForQuestionAnswering""",
					    """CanineForSequenceClassification""",
					    """CanineForTokenClassification""",
					    """CanineLayer""",
					    """CanineModel""",
					    """CaninePreTrainedModel""",
					    """load_tf_weights_in_canine""",
					]


if TYPE_CHECKING:
					from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig
					from .tokenization_canine import CanineTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_canine import (
										    CANINE_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CanineForMultipleChoice,
										    CanineForQuestionAnswering,
										    CanineForSequenceClassification,
										    CanineForTokenClassification,
										    CanineLayer,
										    CanineModel,
										    CaninePreTrainedModel,
										    load_tf_weights_in_canine,
										)


else:
					import sys

					SCREAMING_SNAKE_CASE__   :      Union[str, Any]				=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






