"""simple docstring"""







from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor







class        UpperCamelCase		:
   def __init__(			self     ,__UpperCamelCase     ,__UpperCamelCase=3     ,__UpperCamelCase=32     ,__UpperCamelCase=3     ,__UpperCamelCase=10     ,__UpperCamelCase=[10, 20, 30, 40]     ,__UpperCamelCase=[1, 1, 2, 1]     ,__UpperCamelCase=True     ,__UpperCamelCase=True     ,__UpperCamelCase="relu"     ,__UpperCamelCase=3     ,__UpperCamelCase=None     ,)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_	:				str													=	parent
        lowercase_	:				int													=	batch_size
        lowercase_	:				List[str]													=	image_size
        lowercase_	:				Dict													=	num_channels
        lowercase_	:				List[str]													=	embeddings_size
        lowercase_	:				Union[str, Any]													=	hidden_sizes
        lowercase_	:				Tuple													=	depths
        lowercase_	:				Union[str, Any]													=	is_training
        lowercase_	:				Optional[int]													=	use_labels
        lowercase_	:				Optional[int]													=	hidden_act
        lowercase_	:				Optional[int]													=	num_labels
        lowercase_	:				Tuple													=	scope
        lowercase_	:				Optional[int]													=	len(__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        lowercase_	:				Tuple													=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

        lowercase_	:				str													=	self.get_config()
        return config, pixel_values, labels
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        return RegNetConfig(
            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     ,)
   def 			_UpperCAmelCase   (			self     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      int:


        '''simple docstring'''


        lowercase_	:				Optional[int]													=	TFRegNetModel(config=__UpperCamelCase			)
        lowercase_	:				Dict													=	model(__UpperCamelCase     ,training=__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     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)	->      Any:


        '''simple docstring'''


        lowercase_	:				List[str]													=	self.num_labels
        lowercase_	:				Union[str, Any]													=	TFRegNetForImageClassification(__UpperCamelCase			)
        lowercase_	:				Union[str, Any]													=	model(__UpperCamelCase     ,labels=__UpperCamelCase     ,training=__UpperCamelCase			)
        self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels)			)







   def 			_UpperCAmelCase   (			self			)	->      List[str]:


        '''simple docstring'''


        lowercase_	:				Any													=	self.prepare_config_and_inputs()
        lowercase_							,  lowercase_							,  lowercase_	:				Optional[Any]													=	config_and_inputs
        lowercase_	:				int													=	{'pixel_values': pixel_values}
        return config, inputs_dict







@require_tf
class        UpperCamelCase		(			lowercase_						,      lowercase_						,      unittest.TestCase  ):
   lowercase							=  (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
   lowercase							=  (
       {'feature-extraction': TFRegNetModel, 'image-classification': TFRegNetForImageClassification}
       if is_tf_available()
       else {}
   )

   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   lowercase							=  False
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        lowercase_	:				List[str]													=	TFRegNetModelTester(self			)
        lowercase_	:				str													=	ConfigTester(self     ,config_class=__UpperCamelCase     ,has_text_modality=__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        return
   @unittest.skip(reason='RegNet does not use inputs_embeds'			)
   def 			_UpperCAmelCase   (			self			)	->      str:


        '''simple docstring'''


        pass
   @unittest.skipIf(
       not is_tf_available() or len(tf.config.list_physical_devices('GPU'			)			) == 0     ,reason='TF does not support backprop for grouped convolutions on CPU.'     ,)
   @slow
   def 			_UpperCAmelCase   (			self			)	->      Optional[int]:


        '''simple docstring'''


        super().test_keras_fit()
   @unittest.skip(reason='RegNet does not support input and output embeddings'			)
   def 			_UpperCAmelCase   (			self			)	->      Any:


        '''simple docstring'''


        pass
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


        lowercase_							,  lowercase_	:				Dict													=	self.model_tester.prepare_config_and_inputs_for_common()

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

             lowercase_	:				List[Any]													=	['pixel_values']
             self.assertListEqual(arg_names[:1]     ,__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Optional[Any]:


        '''simple docstring'''


        lowercase_	:				str													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        def check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			):
             lowercase_	:				Union[str, Any]													=	model_class(__UpperCamelCase			)
             lowercase_	:				Tuple													=	model(**self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)     ,training=__UpperCamelCase			)

             lowercase_	:				Optional[int]													=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             lowercase_	:				List[str]													=	self.model_tester.num_stages
             self.assertEqual(len(__UpperCamelCase			)     ,expected_num_stages + 1			)

             # RegNet'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 // 2, self.model_tester.image_size // 2]     ,)

        lowercase_							,  lowercase_	:				List[Any]													=	self.model_tester.prepare_config_and_inputs_for_common()
        lowercase_	:				List[Any]													=	['basic', 'bottleneck']
        for model_class in self.all_model_classes:
             for layer_type in layers_type:
                  lowercase_	:				Union[str, Any]													=	layer_type
                  lowercase_	:				Union[str, Any]													=	True
                  check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)

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

                  check_hidden_states_output(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)
   def 			_UpperCAmelCase   (			self			)	->      Tuple:


        '''simple docstring'''


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

        def check_equivalence(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase={}			):
             lowercase_	:				Tuple													=	model(__UpperCamelCase     ,return_dict=__UpperCamelCase     ,**__UpperCamelCase			)
             lowercase_	:				int													=	model(__UpperCamelCase     ,return_dict=__UpperCamelCase     ,**__UpperCamelCase			).to_tuple()

             def recursive_check(__UpperCamelCase     ,__UpperCamelCase			):
                  if isinstance(__UpperCamelCase     ,(List, Tuple)			):
                       for tuple_iterable_value, dict_iterable_value in zip(__UpperCamelCase     ,__UpperCamelCase			):
                            recursive_check(__UpperCamelCase     ,__UpperCamelCase			)
                  elif tuple_object is None:
                       return
                  else:
                       self.assertTrue(
                           all(tf.equal(__UpperCamelCase     ,__UpperCamelCase			)			)     ,msg=(
                               'Tuple and dict output are not equal. Difference:'
                               f''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object			)			)}'''
                           )     ,)

                  recursive_check(__UpperCamelCase     ,__UpperCamelCase			)

        for model_class in self.all_model_classes:
             lowercase_	:				List[str]													=	model_class(__UpperCamelCase			)

             lowercase_	:				int													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)
             lowercase_	:				List[str]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)
             check_equivalence(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				Optional[int]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)
             lowercase_	:				int													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)
             check_equivalence(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase			)

             lowercase_	:				Tuple													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)
             lowercase_	:				Optional[int]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase			)
             check_equivalence(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase     ,{'output_hidden_states': True}			)

             lowercase_	:				Union[str, Any]													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)
             lowercase_	:				int													=	self._prepare_for_class(__UpperCamelCase     ,__UpperCamelCase     ,return_labels=__UpperCamelCase			)
             check_equivalence(__UpperCamelCase     ,__UpperCamelCase     ,__UpperCamelCase     ,{'output_hidden_states': True}			)
   def 			_UpperCAmelCase   (			self			)	->      List[Any]:


        '''simple docstring'''


        lowercase_	:				Union[str, Any]													=	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase			)







   @slow
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase_	:				Optional[int]													=	TFRegNetModel.from_pretrained(__UpperCamelCase			)
             self.assertIsNotNone(__UpperCamelCase			)






def 			lowercase__(       ):
     lowercase_	:				Optional[Any]													=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
     return image







@require_tf
@require_vision
class        UpperCamelCase		(			unittest.TestCase  ):
   @cached_property
   def 			_UpperCAmelCase   (			self			)	->      Union[str, Any]:


        '''simple docstring'''


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







   @slow
   def 			_UpperCAmelCase   (			self			)	->      int:


        '''simple docstring'''


        lowercase_	:				int													=	TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

        lowercase_	:				int													=	self.default_image_processor
        lowercase_	:				Optional[int]													=	prepare_img()
        lowercase_	:				Tuple													=	image_processor(images=__UpperCamelCase     ,return_tensors='tf'			)

        # forward pass
        lowercase_	:				List[Any]													=	model(**__UpperCamelCase     ,training=__UpperCamelCase			)

        # verify the logits
        lowercase_	:				Dict													=	tf.TensorShape((1, 1000)			)
        self.assertEqual(outputs.logits.shape     ,__UpperCamelCase			)

        lowercase_	:				Optional[Any]													=	tf.constant([-0.4180, -1.5051, -3.4836]			)

        tf.debugging.assert_near(outputs.logits[0, :3]     ,__UpperCamelCase     ,atol=1e-4			)


"""simple docstring"""







import warnings

from ...utils import logging
from .image_processing_beit import BeitImageProcessor


__SCREAMING_SNAKE_CASE    	=logging.get_logger(__name__)







class        UpperCamelCase		(			lowercase_  ):
   def __init__(			self     ,*__UpperCamelCase     ,**__UpperCamelCase			)	->      None:


        '''simple docstring'''


        warnings.warn(
            'The class BeitFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
            ' use BeitImageProcessor instead.'     ,__UpperCamelCase     ,)
        super().__init__(*__UpperCamelCase     ,**__UpperCamelCase			)

