






from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import ConvNextConfig
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 TFConvNextForImageClassification, TFConvNextModel


if is_vision_available():
     from PIL import Image

     from transformers import ConvNextImageProcessor






class 	lowercase_      :






      '''simple docstring'''




      def __init__(   self   :		str				,      __UpperCAmelCase   :		List[Any]				,      __UpperCAmelCase   :		Tuple=13				,      __UpperCAmelCase   :		Tuple=32				,      __UpperCAmelCase   :		Optional[Any]=3				,      __UpperCAmelCase   :		Union[str, Any]=4				,      __UpperCAmelCase   :		List[Any]=[10, 20, 30, 40]				,      __UpperCAmelCase   :		List[Any]=[2, 2, 3, 2]				,      __UpperCAmelCase   :		Optional[Any]=True				,      __UpperCAmelCase   :		str=True				,      __UpperCAmelCase   :		Any=37				,      __UpperCAmelCase   :		List[Any]="gelu"				,      __UpperCAmelCase   :		Optional[Any]=10				,      __UpperCAmelCase   :		List[Any]=0.02				,      __UpperCAmelCase   :		Any=3				,      __UpperCAmelCase   :		Dict=None				,      )					->List[str]:




       """simple docstring"""


       a							=   parent
       a							=   batch_size
       a							=   image_size
       a							=   num_channels
       a							=   num_stages
       a							=   hidden_sizes
       a							=   depths
       a							=   is_training
       a							=   use_labels
       a							=   intermediate_size
       a							=   hidden_act
       a							=   type_sequence_label_size
       a							=   initializer_range
       a							=   scope







      def    __lowerCAmelCase      (   self   :		Optional[Any]						)					->List[Any]:




       """simple docstring"""


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

       a							=   None
       if self.use_labels:
        a							=   ids_tensor([self.batch_size]				,      self.type_sequence_label_size						)

       a							=   self.get_config()

       return config, pixel_values, labels







      def    __lowerCAmelCase      (   self   :		Any						)					->Dict:




       """simple docstring"""


       return ConvNextConfig(
           num_channels=self.num_channels				,      hidden_sizes=self.hidden_sizes				,      depths=self.depths				,      num_stages=self.num_stages				,      hidden_act=self.hidden_act				,      is_decoder=__UpperCAmelCase				,      initializer_range=self.initializer_range				,      )







      def    __lowerCAmelCase      (   self   :		str				,      __UpperCAmelCase   :		Optional[Any]				,      __UpperCAmelCase   :		List[Any]				,      __UpperCAmelCase   :		List[str]						)					->str:




       """simple docstring"""


       a							=   TFConvNextModel(config=__UpperCAmelCase						)
       a							=   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    __lowerCAmelCase      (   self   :		Tuple				,      __UpperCAmelCase   :		Union[str, Any]				,      __UpperCAmelCase   :		List[str]				,      __UpperCAmelCase   :		int						)					->Optional[Any]:




       """simple docstring"""


       a							=   self.type_sequence_label_size
       a							=   TFConvNextForImageClassification(__UpperCAmelCase						)
       a							=   model(__UpperCAmelCase				,      labels=__UpperCAmelCase				,      training=__UpperCAmelCase						)
       self.parent.assertEqual(result.logits.shape				,      (self.batch_size, self.type_sequence_label_size)						)







      def    __lowerCAmelCase      (   self   :		Dict						)					->str:




       """simple docstring"""


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






@require_tf
class 	lowercase_      (			lowercase				,						lowercase				,						unittest.TestCase     ):






      '''simple docstring'''




      __snake_case  						=						(TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
      __snake_case  						=						(
          {'''feature-extraction''': TFConvNextModel, '''image-classification''': TFConvNextForImageClassification}
          if is_tf_available()
          else {}
      )

      __snake_case  						=						False
      __snake_case  						=						False
      __snake_case  						=						False
      __snake_case  						=						False
      __snake_case  						=						False







      def    __lowerCAmelCase      (   self   :		List[Any]						)					->List[Any]:




       """simple docstring"""


       a							=   TFConvNextModelTester(self						)
       a							=   ConfigTester(
           self				,      config_class=__UpperCAmelCase				,      has_text_modality=__UpperCAmelCase				,      hidden_size=37				,      )







      @unittest.skip(reason='''ConvNext does not use inputs_embeds'''						)
      def    __lowerCAmelCase      (   self   :		Any						)					->List[Any]:




       """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    __lowerCAmelCase      (   self   :		List[Any]						)					->Any:




       """simple docstring"""


       super().test_keras_fit()







      @unittest.skip(reason='''ConvNext does not support input and output embeddings'''						)
      def    __lowerCAmelCase      (   self   :		Optional[int]						)					->List[Any]:




       """simple docstring"""


       pass







      def    __lowerCAmelCase      (   self   :		List[str]						)					->Optional[int]:




       """simple docstring"""


       a						,  a							=   self.model_tester.prepare_config_and_inputs_for_common()

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

        a							=   ['''pixel_values''']
        self.assertListEqual(arg_names[:1]				,      __UpperCAmelCase						)







      def    __lowerCAmelCase      (   self   :		Union[str, Any]						)					->Any:




       """simple docstring"""


       a							=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__UpperCAmelCase						)







      @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.'''				,      )
      def    __lowerCAmelCase      (   self   :		Any						)					->List[str]:




       """simple docstring"""


       super().test_dataset_conversion()







      def    __lowerCAmelCase      (   self   :		Tuple						)					->Tuple:




       """simple docstring"""


       def check_hidden_states_output(__UpperCAmelCase   :		List[Any]				,      __UpperCAmelCase   :		Union[str, Any]				,      __UpperCAmelCase   :		Tuple						):
        a							=   model_class(__UpperCAmelCase						)

        a							=   model(**self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase						)						)
        a							=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        a							=   self.model_tester.num_stages
        self.assertEqual(len(__UpperCAmelCase						)				,      expected_num_stages + 1						)

        # ConvNext'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							=   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        a							=   True
        check_hidden_states_output(__UpperCAmelCase				,      __UpperCAmelCase				,      __UpperCAmelCase						)

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

        check_hidden_states_output(__UpperCAmelCase				,      __UpperCAmelCase				,      __UpperCAmelCase						)







      def    __lowerCAmelCase      (   self   :		List[str]						)					->Tuple:




       """simple docstring"""


       a						,  a							=   self.model_tester.prepare_config_and_inputs_for_common()

       def check_equivalence(__UpperCAmelCase   :		Dict				,      __UpperCAmelCase   :		str				,      __UpperCAmelCase   :		Any				,      __UpperCAmelCase   :		Tuple={}						):
        a							=   model(__UpperCAmelCase				,      return_dict=__UpperCAmelCase				,      **__UpperCAmelCase						)
        a							=   model(__UpperCAmelCase				,      return_dict=__UpperCAmelCase				,      **__UpperCAmelCase						).to_tuple()

        def recursive_check(__UpperCAmelCase   :		int				,      __UpperCAmelCase   :		Tuple						):
         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:
        a							=   model_class(__UpperCAmelCase						)

        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase						)
        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase						)
        check_equivalence(__UpperCAmelCase				,      __UpperCAmelCase				,      __UpperCAmelCase						)

        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase				,      return_labels=__UpperCAmelCase						)
        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase				,      return_labels=__UpperCAmelCase						)
        check_equivalence(__UpperCAmelCase				,      __UpperCAmelCase				,      __UpperCAmelCase						)

        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase						)
        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase						)
        check_equivalence(__UpperCAmelCase				,      __UpperCAmelCase				,      __UpperCAmelCase				,      {'''output_hidden_states''': True}						)

        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase				,      return_labels=__UpperCAmelCase						)
        a							=   self._prepare_for_class(__UpperCAmelCase				,      __UpperCAmelCase				,      return_labels=__UpperCAmelCase						)
        check_equivalence(__UpperCAmelCase				,      __UpperCAmelCase				,      __UpperCAmelCase				,      {'''output_hidden_states''': True}						)







      def    __lowerCAmelCase      (   self   :		Any						)					->int:




       """simple docstring"""


       a							=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase						)







      @slow
      def    __lowerCAmelCase      (   self   :		Optional[Any]						)					->List[str]:




       """simple docstring"""


       a							=   TFConvNextModel.from_pretrained('''facebook/convnext-tiny-224'''						)
       self.assertIsNotNone(__UpperCAmelCase						)
def 		_a					(   )							->    Optional[Any]:
 a							=   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
 return image






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






      '''simple docstring'''




      @cached_property
      def    __lowerCAmelCase      (   self   :		int						)					->Any:




       """simple docstring"""


       return ConvNextImageProcessor.from_pretrained('''facebook/convnext-tiny-224'''						) if is_vision_available() else None







      @slow
      def    __lowerCAmelCase      (   self   :		Tuple						)					->Tuple:




       """simple docstring"""


       a							=   TFConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''						)

       a							=   self.default_image_processor
       a							=   prepare_img()
       a							=   image_processor(images=__UpperCAmelCase				,      return_tensors='''tf'''						)

       # forward pass
       a							=   model(**__UpperCAmelCase						)

       # verify the logits
       a							=   tf.TensorShape((1, 1_000)						)
       self.assertEqual(outputs.logits.shape				,      __UpperCAmelCase						)

       a							=   tf.constant([-0.0260, -0.4739, 0.1911]						)

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










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__            =	{"configuration_visual_bert": ["VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VisualBertConfig"]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase__            =	[
         "VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "VisualBertForMultipleChoice",
         "VisualBertForPreTraining",
         "VisualBertForQuestionAnswering",
         "VisualBertForRegionToPhraseAlignment",
         "VisualBertForVisualReasoning",
         "VisualBertLayer",
         "VisualBertModel",
         "VisualBertPreTrainedModel",
     ]


if TYPE_CHECKING:
     from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_visual_bert import (
              VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              VisualBertForMultipleChoice,
              VisualBertForPreTraining,
              VisualBertForQuestionAnswering,
              VisualBertForRegionToPhraseAlignment,
              VisualBertForVisualReasoning,
              VisualBertLayer,
              VisualBertModel,
              VisualBertPreTrainedModel,
          )


else:
     import sys

     UpperCAmelCase__            =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


