





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


  '''simple docstring'''







  def __init__(      self      :					Union[str, Any]      ,				UpperCamelCase      :					Any      ,				UpperCamelCase      :					Any=3      ,				UpperCamelCase      :					str=32      ,				UpperCamelCase      :					int=3      ,				UpperCamelCase      :					Union[str, Any]=10      ,				UpperCamelCase      :					Tuple=[10, 20, 30, 40]      ,				UpperCamelCase      :					str=[1, 1, 2, 1]      ,				UpperCamelCase      :					Tuple=True      ,				UpperCamelCase      :					Any=True      ,				UpperCamelCase      :					int="relu"      ,				UpperCamelCase      :					Optional[int]=3      ,				UpperCamelCase      :					Optional[Any]=None      ,				):


    '''simple docstring'''





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







  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				Any														=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

    _snake_case   :				Tuple														=	self.get_config()

    return config, pixel_values, labels







  def UpperCamelCase_ (      self      :					str							):


    '''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      :					Tuple      ,				UpperCamelCase      :					int      ,				UpperCamelCase      :					List[Any]      ,				UpperCamelCase      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	TFResNetModel(config=UpperCamelCase							)
    _snake_case   :				str														=	model(UpperCamelCase							)
    # 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 UpperCamelCase_ (      self      :					Any      ,				UpperCamelCase      :					List[Any]      ,				UpperCamelCase      :					Optional[int]      ,				UpperCamelCase      :					Union[str, Any]							):


    '''simple docstring'''





    _snake_case   :				Dict														=	self.num_labels
    _snake_case   :				Optional[Any]														=	TFResNetForImageClassification(UpperCamelCase							)
    _snake_case   :				List[Any]														=	model(UpperCamelCase      ,				labels=UpperCamelCase							)
    self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels)							)







  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





    _snake_case   :				Any														=	self.prepare_config_and_inputs()
    _snake_case							,					_snake_case							,					_snake_case   :				Tuple														=	config_and_inputs
    _snake_case   :				List[str]														=	{'pixel_values': pixel_values}
    return config, inputs_dict




@require_tf
class        _lowerCAmelCase    (			UpperCAmelCase_							,    UpperCAmelCase_							,    unittest.TestCase							):


  '''simple docstring'''
  a_							:       str      					=(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
  a_							:       Union[str, Any]      					=(
      {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
      if is_tf_available()
      else {}
  )

  a_							:       Optional[Any]      					=False
  a_							:       List[Any]      					=False
  a_							:       Any      					=False
  a_							:       str      					=False
  a_							:       List[str]      					=False







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	TFResNetModelTester(self							)
    _snake_case   :				List[str]														=	ConfigTester(self      ,				config_class=UpperCamelCase      ,				has_text_modality=UpperCamelCase							)







  def UpperCamelCase_ (      self      :					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      :					int							):


    '''simple docstring'''





    return







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


    '''simple docstring'''





    pass







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


    '''simple docstring'''





    pass







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case							,					_snake_case   :				Tuple														=	self.model_tester.prepare_config_and_inputs_for_common()

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

      _snake_case   :				Union[str, Any]														=	['pixel_values']
      self.assertListEqual(arg_names[:1]      ,				UpperCamelCase							)







  def UpperCamelCase_ (      self      :					List[Any]							):


    '''simple docstring'''





    _snake_case   :				Optional[int]														=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*UpperCamelCase							)







  def UpperCamelCase_ (      self      :					str							):


    '''simple docstring'''





    def check_hidden_states_output(UpperCamelCase      :					Optional[Any]      ,				UpperCamelCase      :					Union[str, Any]      ,				UpperCamelCase      :					Optional[int]							):
      _snake_case   :				Union[str, Any]														=	model_class(UpperCamelCase							)
      _snake_case   :				str														=	model(**self._prepare_for_class(UpperCamelCase      ,				UpperCamelCase							)							)

      _snake_case   :				List[Any]														=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

      _snake_case   :				int														=	self.model_tester.num_stages
      self.assertEqual(len(UpperCamelCase							)      ,				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]      ,				)

    _snake_case							,					_snake_case   :				Dict														=	self.model_tester.prepare_config_and_inputs_for_common()
    _snake_case   :				Union[str, Any]														=	['basic', 'bottleneck']
    for model_class in self.all_model_classes:
      for layer_type in layers_type:
        _snake_case   :				int														=	layer_type
        _snake_case   :				Optional[Any]														=	True
        check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)

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

        check_hidden_states_output(UpperCamelCase      ,				UpperCamelCase      ,				UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*UpperCamelCase							)







  @slow
  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      _snake_case   :				Union[str, Any]														=	TFResNetModel.from_pretrained(UpperCamelCase							)
      self.assertIsNotNone(UpperCamelCase							)




def     lowerCamelCase_	(      )->		Dict:
  _snake_case   :				Optional[Any]														=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
  return image







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


  '''simple docstring'''







  @cached_property
  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





    return (
        AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
        if is_vision_available()
        else None
    )







  @slow
  def UpperCamelCase_ (      self      :					str							):


    '''simple docstring'''





    _snake_case   :				Any														=	TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)

    _snake_case   :				str														=	self.default_image_processor
    _snake_case   :				Union[str, Any]														=	prepare_img()
    _snake_case   :				Tuple														=	image_processor(images=UpperCamelCase      ,				return_tensors='tf'							)

    # forward pass
    _snake_case   :				List[str]														=	model(**UpperCamelCase							)

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

    _snake_case   :				List[Any]														=	tf.constant([-11.10_69, -9.78_77, -8.37_77]							)

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











def     lowerCamelCase_	(      lowerCAmelCase:	int				)->		int:

  if not isinstance(lowerCAmelCase    ,							lowerCAmelCase				):
    _snake_case   :				Union[str, Any]														=	F"""Input value of [number={number}] must be an integer"""
    raise TypeError(lowerCAmelCase				)

  if number < 1:
    _snake_case   :				int														=	F"""Input value of [number={number}] must be > 0"""
    raise ValueError(lowerCAmelCase				)

  _snake_case   :				int														=	1

  for i in range(1    ,							lowerCAmelCase				):
    current_number *= 4 * i - 2
    current_number //= i + 1

  return current_number


if __name__ == "__main__":
      import doctest

      doctest.testmod()




