
"""simple docstring"""





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




  '''simple docstring'''







  def __init__(						self							,  lowercase_							,  lowercase_=13							,  lowercase_=32							,  lowercase_=3							,  lowercase_=4							,  lowercase_=[10, 20, 30, 40]							,  lowercase_=[2, 2, 3, 2]							,  lowercase_=True							,  lowercase_=True							,  lowercase_=37							,  lowercase_="gelu"							,  lowercase_=10							,  lowercase_=0.02							,  lowercase_=3							,  lowercase_=None							,  ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       parent
     UpperCAmelCase_   :   int     	=       batch_size
     UpperCAmelCase_   :   int     	=       image_size
     UpperCAmelCase_   :   Union[str, Any]     	=       num_channels
     UpperCAmelCase_   :   Any     	=       num_stages
     UpperCAmelCase_   :   Dict     	=       hidden_sizes
     UpperCAmelCase_   :   List[Any]     	=       depths
     UpperCAmelCase_   :   Tuple     	=       is_training
     UpperCAmelCase_   :   Union[str, Any]     	=       use_labels
     UpperCAmelCase_   :   List[str]     	=       intermediate_size
     UpperCAmelCase_   :   Union[str, Any]     	=       hidden_act
     UpperCAmelCase_   :   Tuple     	=       type_sequence_label_size
     UpperCAmelCase_   :   Any     	=       initializer_range
     UpperCAmelCase_   :   Union[str, Any]     	=       scope







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   List[str]     	=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

     UpperCAmelCase_   :   Any     	=       None
     if self.use_labels:
        UpperCAmelCase_   :   str     	=       ids_tensor([self.batch_size]							,  self.type_sequence_label_size    )

     UpperCAmelCase_   :   int     	=       self.get_config()

     return config, pixel_values, labels







  def 			UpperCamelCase__   (						self    ):

     """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=lowercase_							,  initializer_range=self.initializer_range							,  )







  def 			UpperCamelCase__   (						self							,  lowercase_							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   str     	=       TFConvNextModel(config=lowercase_    )
     UpperCAmelCase_   :   Tuple     	=       model(lowercase_							,  training=lowercase_    )
     # 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							,  lowercase_							,  lowercase_							,  lowercase_    ):

     """simple docstring"""
     UpperCAmelCase_   :   Union[str, Any]     	=       self.type_sequence_label_size
     UpperCAmelCase_   :   int     	=       TFConvNextForImageClassification(lowercase_    )
     UpperCAmelCase_   :   int     	=       model(lowercase_							,  labels=lowercase_							,  training=lowercase_    )
     self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.type_sequence_label_size)    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Any     	=       self.prepare_config_and_inputs()
     UpperCAmelCase_	,  UpperCAmelCase_	,  UpperCAmelCase_   :   Any     	=       config_and_inputs
     UpperCAmelCase_   :   List[Any]     	=       {"pixel_values": pixel_values}
     return config, inputs_dict




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




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__     :		str    	=						(TFConvNextModel, TFConvNextForImageClassification) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__     :		Dict    	=						(
      {"""feature-extraction""": TFConvNextModel, """image-classification""": TFConvNextForImageClassification}
      if is_tf_available()
      else {}
  )

  SCREAMING_SNAKE_CASE__     :		Tuple    	=						False
  SCREAMING_SNAKE_CASE__     :		Union[str, Any]    	=						False
  SCREAMING_SNAKE_CASE__     :		Union[str, Any]    	=						False
  SCREAMING_SNAKE_CASE__     :		str    	=						False
  SCREAMING_SNAKE_CASE__     :		Any    	=						False







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   str     	=       TFConvNextModelTester(self    )
     UpperCAmelCase_   :   Union[str, Any]     	=       ConfigTester(
         self							,  config_class=lowercase_							,  has_text_modality=lowercase_							,  hidden_size=37							,  )







  @unittest.skip(reason="ConvNext does not use inputs_embeds"    )
  def 			UpperCamelCase__   (						self    ):

     """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    ):

     """simple docstring"""
     super().test_keras_fit()







  @unittest.skip(reason="ConvNext does not support input and output embeddings"    )
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     pass







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[int]     	=       self.model_tester.prepare_config_and_inputs_for_common()

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

        UpperCAmelCase_   :   int     	=       ["pixel_values"]
        self.assertListEqual(arg_names[:1]							,  lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   int     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_    )







  @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 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     super().test_dataset_conversion()







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     def check_hidden_states_output(lowercase_							,  lowercase_							,  lowercase_    ):
        UpperCAmelCase_   :   Dict     	=       model_class(lowercase_    )

        UpperCAmelCase_   :   List[str]     	=       model(**self._prepare_for_class(lowercase_							,  lowercase_    )    )
        UpperCAmelCase_   :   List[Any]     	=       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

        UpperCAmelCase_   :   List[Any]     	=       self.model_tester.num_stages
        self.assertEqual(len(lowercase_    )							,  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]							,  )

     UpperCAmelCase_	,  UpperCAmelCase_   :   str     	=       self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        UpperCAmelCase_   :   Dict     	=       True
        check_hidden_states_output(lowercase_							,  lowercase_							,  lowercase_    )

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

        check_hidden_states_output(lowercase_							,  lowercase_							,  lowercase_    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Union[str, Any]     	=       self.model_tester.prepare_config_and_inputs_for_common()

     def check_equivalence(lowercase_							,  lowercase_							,  lowercase_							,  lowercase_={}    ):
        UpperCAmelCase_   :   Optional[int]     	=       model(lowercase_							,  return_dict=lowercase_							,  **lowercase_    )
        UpperCAmelCase_   :   Optional[Any]     	=       model(lowercase_							,  return_dict=lowercase_							,  **lowercase_    ).to_tuple()

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

           recursive_check(lowercase_							,  lowercase_    )

     for model_class in self.all_model_classes:
        UpperCAmelCase_   :   Optional[int]     	=       model_class(lowercase_    )

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

        UpperCAmelCase_   :   Optional[Any]     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        UpperCAmelCase_   :   List[str]     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_    )

        UpperCAmelCase_   :   str     	=       self._prepare_for_class(lowercase_							,  lowercase_    )
        UpperCAmelCase_   :   Tuple     	=       self._prepare_for_class(lowercase_							,  lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_							,  {"output_hidden_states": True}    )

        UpperCAmelCase_   :   Any     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        UpperCAmelCase_   :   Optional[Any]     	=       self._prepare_for_class(lowercase_							,  lowercase_							,  return_labels=lowercase_    )
        check_equivalence(lowercase_							,  lowercase_							,  lowercase_							,  {"output_hidden_states": True}    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Dict     	=       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*lowercase_    )







  @slow
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       TFConvNextModel.from_pretrained("facebook/convnext-tiny-224"    )
     self.assertIsNotNone(lowercase_    )







def       __a	(						):
   UpperCAmelCase_   :   Tuple     	=       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    ):

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







  @slow
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Optional[Any]     	=       TFConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"    )

     UpperCAmelCase_   :   str     	=       self.default_image_processor
     UpperCAmelCase_   :   Optional[Any]     	=       prepare_img()
     UpperCAmelCase_   :   Dict     	=       image_processor(images=lowercase_							,  return_tensors="tf"    )

     # forward pass
     UpperCAmelCase_   :   Optional[int]     	=       model(**lowercase_    )

     # verify the logits
     UpperCAmelCase_   :   List[str]     	=       tf.TensorShape((1, 1000)    )
     self.assertEqual(outputs.logits.shape							,  lowercase_    )

     UpperCAmelCase_   :   Any     	=       tf.constant([-0.02_60, -0.47_39, 0.19_11]    )

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









"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import BlipImageProcessor






class    _UpperCAmelCase  (      unittest.TestCase					):


					def __init__(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :Dict=7	,			__UpperCamelCase     :Optional[Any]=3	,			__UpperCamelCase     :Tuple=18	,			__UpperCamelCase     :List[Any]=30	,			__UpperCamelCase     :Optional[Any]=4_00	,			__UpperCamelCase     :Union[str, Any]=True	,			__UpperCamelCase     :Tuple=None	,			__UpperCamelCase     :List[str]=True	,			__UpperCamelCase     :Any=False	,			__UpperCamelCase     :str=[0.48_145_466, 0.4_578_275, 0.40_821_073]	,			__UpperCamelCase     :Optional[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]	,			__UpperCamelCase     :Optional[Any]=True	,			):
												A						=    size if size is not None else {"height": 20, "width": 20}
												A						=    parent
												A						=    batch_size
												A						=    num_channels
												A						=    image_size
												A						=    min_resolution
												A						=    max_resolution
												A						=    do_resize
												A						=    size
												A						=    do_normalize
												A						=    image_mean
												A						=    image_std
												A						=    do_pad
												A						=    do_convert_rgb


					def       lowerCamelCase			(   self     :List[str]						):
												return {
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "do_normalize": self.do_normalize,
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_convert_rgb": self.do_convert_rgb,
												    "do_pad": self.do_pad,
												}


					def       lowerCamelCase			(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]=False	,			__UpperCamelCase     :Dict=False	,			__UpperCamelCase     :Dict=False						):
												assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

												if equal_resolution:
																			A						=    []
																			for i in range(self.batch_size						):
																										image_inputs.append(
																										    np.random.randint(
																										        2_55	,			size=(self.num_channels, self.max_resolution, self.max_resolution)	,			dtype=np.uinta						)						)
												else:
																			A						=    []
																			for i in range(self.batch_size						):
																										A,      A						=    np.random.choice(np.arange(self.min_resolution	,			self.max_resolution						)	,			2						)
																										image_inputs.append(np.random.randint(2_55	,			size=(self.num_channels, width, height)	,			dtype=np.uinta						)						)

												if not numpify and not torchify:
																			# PIL expects the channel dimension as last dimension
																			A						=    [Image.fromarray(np.moveaxis(__UpperCamelCase	,			0	,			-1						)						) for x in image_inputs]

												if torchify:
																			A						=    [torch.from_numpy(__UpperCamelCase						) for x in image_inputs]

												return image_inputs







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A						=    BlipImageProcessingTester(self						)


					@property
					def       lowerCamelCase			(   self     :List[str]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :Any						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :List[Any]						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


					def       lowerCamelCase			(   self     :Union[str, Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random numpy tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			numpify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			np.ndarray						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


					def       lowerCamelCase			(   self     :Tuple						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PyTorch tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			torchify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			torch.Tensor						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :int						):
												A						=    BlipImageProcessingTester(self	,			num_channels=4						)
												A						=    3


					@property
					def       lowerCamelCase			(   self     :Optional[Any]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :int						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :Any						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    image_processor(image_inputs[0]	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        1,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)

												# Test batched
												A						=    image_processor(__UpperCamelCase	,			return_tensors="pt"						).pixel_values
												self.assertEqual(
												    encoded_images.shape	,			(
												        self.image_processor_tester.batch_size,
												        self.expected_encoded_image_num_channels,
												        self.image_processor_tester.size["height"],
												        self.image_processor_tester.size["width"],
												    )	,			)


