






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






 """simple docstring"""





 def __init__(							self			,     __lowerCAmelCase			,     __lowerCAmelCase=3			,     __lowerCAmelCase=32			,     __lowerCAmelCase=3			,     __lowerCAmelCase=10			,     __lowerCAmelCase=[10, 20, 30, 40]			,     __lowerCAmelCase=[1, 1, 2, 1]			,     __lowerCAmelCase=True			,     __lowerCAmelCase=True			,     __lowerCAmelCase="relu"			,     __lowerCAmelCase=3			,     __lowerCAmelCase=None			,     ):
       UpperCamelCase_				:   Dict					    =							parent
       UpperCamelCase_				:   Optional[Any]					    =							batch_size
       UpperCamelCase_				:   Optional[int]					    =							image_size
       UpperCamelCase_				:   str					    =							num_channels
       UpperCamelCase_				:   List[Any]					    =							embeddings_size
       UpperCamelCase_				:   Tuple					    =							hidden_sizes
       UpperCamelCase_				:   List[Any]					    =							depths
       UpperCamelCase_				:   Optional[int]					    =							is_training
       UpperCamelCase_				:   int					    =							use_labels
       UpperCamelCase_				:   str					    =							hidden_act
       UpperCamelCase_				:   int					    =							num_labels
       UpperCamelCase_				:   Dict					    =							scope
       UpperCamelCase_				:   Union[str, Any]					    =							len(UpperCAmelCase__ )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Tuple					    =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

       UpperCamelCase_				:   Optional[Any]					    =							None
       if self.use_labels:
             UpperCamelCase_				:   List[str]					    =							ids_tensor([self.batch_size]			,     self.num_labels )

       UpperCamelCase_				:   Optional[Any]					    =							self.get_config()
       return config, pixel_values, labels
 def   _UpperCAmelCase       (							self ):
       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			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase ):
       UpperCamelCase_				:   Tuple					    =							TFRegNetModel(config=UpperCAmelCase__ )
       UpperCamelCase_				:   List[str]					    =							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			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase ):
       UpperCamelCase_				:   Any					    =							self.num_labels
       UpperCamelCase_				:   List[str]					    =							TFRegNetForImageClassification(UpperCAmelCase__ )
       UpperCamelCase_				:   List[Any]					    =							model(UpperCAmelCase__			,     labels=UpperCAmelCase__			,     training=UpperCAmelCase__ )
       self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels) )





 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.prepare_config_and_inputs()
       UpperCamelCase_				:   int					    =							config_and_inputs
       UpperCamelCase_				:   int					    =							{'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_tf
class     A    (      lowercase__,   lowercase__,   unittest.TestCase						):






 """simple docstring"""





 __a			:						str      =						(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
 __a			:						Union[str, Any]      =						(
     {'''feature-extraction''': TFRegNetModel, '''image-classification''': TFRegNetForImageClassification}
     if is_tf_available()
     else {}
 )

 __a			:						int      =						False
 __a			:						int      =						False
 __a			:						List[str]      =						False
 __a			:						Dict      =						False
 __a			:						Any      =						False
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Union[str, Any]					    =							TFRegNetModelTester(self )
       UpperCamelCase_				:   Tuple					    =							ConfigTester(self			,     config_class=UpperCAmelCase__			,     has_text_modality=UpperCAmelCase__ )
 def   _UpperCAmelCase       (							self ):
       return
 @unittest.skip(reason="""RegNet does not use inputs_embeds""" )
 def   _UpperCAmelCase       (							self ):
       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 ):
       super().test_keras_fit()
 @unittest.skip(reason="""RegNet does not support input and output embeddings""" )
 def   _UpperCAmelCase       (							self ):
       pass
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCamelCase_				:   Any					    =							['''pixel_values''']
             self.assertListEqual(arg_names[:1]			,     UpperCAmelCase__ )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCAmelCase__ )
 def   _UpperCAmelCase       (							self ):
       def check_hidden_states_output(__lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase ):
             UpperCamelCase_				:   Any					    =							model_class(UpperCAmelCase__ )
             UpperCamelCase_				:   Optional[Any]					    =							model(**self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__ )			,     training=UpperCAmelCase__ )

             UpperCamelCase_				:   Dict					    =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             UpperCamelCase_				:   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]			,     )

       UpperCamelCase_				:   Optional[Any]					    =							self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase_				:   Dict					    =							['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
             for layer_type in layers_type:
                   UpperCamelCase_				:   str					    =							layer_type
                   UpperCamelCase_				:   List[Any]					    =							True
                   check_hidden_states_output(UpperCAmelCase__			,     UpperCAmelCase__			,     UpperCAmelCase__ )

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

                   check_hidden_states_output(UpperCAmelCase__			,     UpperCAmelCase__			,     UpperCAmelCase__ )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   int					    =							self.model_tester.prepare_config_and_inputs_for_common()

       def check_equivalence(__lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase			,     __lowerCAmelCase={} ):
             UpperCamelCase_				:   Optional[Any]					    =							model(UpperCAmelCase__			,     return_dict=UpperCAmelCase__			,     **UpperCAmelCase__ )
             UpperCamelCase_				:   List[str]					    =							model(UpperCAmelCase__			,     return_dict=UpperCAmelCase__			,     **UpperCAmelCase__ ).to_tuple()

             def recursive_check(__lowerCAmelCase			,     __lowerCAmelCase ):
                   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:
             UpperCamelCase_				:   Optional[Any]					    =							model_class(UpperCAmelCase__ )

             UpperCamelCase_				:   int					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__ )
             UpperCamelCase_				:   Any					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__ )
             check_equivalence(UpperCAmelCase__			,     UpperCAmelCase__			,     UpperCAmelCase__ )

             UpperCamelCase_				:   List[str]					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__			,     return_labels=UpperCAmelCase__ )
             UpperCamelCase_				:   str					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__			,     return_labels=UpperCAmelCase__ )
             check_equivalence(UpperCAmelCase__			,     UpperCAmelCase__			,     UpperCAmelCase__ )

             UpperCamelCase_				:   List[Any]					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__ )
             UpperCamelCase_				:   str					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__ )
             check_equivalence(UpperCAmelCase__			,     UpperCAmelCase__			,     UpperCAmelCase__			,     {"""output_hidden_states""": True} )

             UpperCamelCase_				:   int					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__			,     return_labels=UpperCAmelCase__ )
             UpperCamelCase_				:   str					    =							self._prepare_for_class(UpperCAmelCase__			,     UpperCAmelCase__			,     return_labels=UpperCAmelCase__ )
             check_equivalence(UpperCAmelCase__			,     UpperCAmelCase__			,     UpperCAmelCase__			,     {"""output_hidden_states""": True} )
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[Any]					    =							self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__ )





 @slow
 def   _UpperCAmelCase       (							self ):
       for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase_				:   Any					    =							TFRegNetModel.from_pretrained(UpperCAmelCase__ )
             self.assertIsNotNone(UpperCAmelCase__ )






def 							snake_case					(     )       ->				str:





      """simple docstring"""

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




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






 """simple docstring"""





 @cached_property
 def   _UpperCAmelCase       (							self ):
       return (
           AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
           if is_vision_available()
           else None
       )





 @slow
 def   _UpperCAmelCase       (							self ):
       UpperCamelCase_				:   Optional[int]					    =							TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )

       UpperCamelCase_				:   Dict					    =							self.default_image_processor
       UpperCamelCase_				:   str					    =							prepare_img()
       UpperCamelCase_				:   Dict					    =							image_processor(images=UpperCAmelCase__			,     return_tensors="""tf""" )

       # forward pass
       UpperCamelCase_				:   Optional[int]					    =							model(**UpperCAmelCase__			,     training=UpperCAmelCase__ )

       # verify the logits
       UpperCamelCase_				:   Optional[Any]					    =							tf.TensorShape((1, 10_00) )
       self.assertEqual(outputs.logits.shape			,     UpperCAmelCase__ )

       UpperCamelCase_				:   Optional[int]					    =							tf.constant([-0.41_80, -1.50_51, -3.48_36] )

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














'''simple docstring'''

# flake8: noqa
# Lint as: python3
UpperCamelCase							=[
    "VerificationMode",
    "Version",
    "disable_progress_bar",
    "enable_progress_bar",
    "is_progress_bar_enabled",
    "experimental",
]

from .info_utils import VerificationMode
from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled
from .version import Version
from .experimental import experimental






