
'''simple docstring'''






import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
					from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor




class     __snake_case		:
					def __init__(     self,    A,    A=13,    A=32,    A=3,    A=4,    A=[10, 20, 30, 40],    A=[2, 2, 3, 2],    A=True,    A=True,    A=37,    A="gelu",    A=10,    A=0.02,    A=["stage2", "stage3", "stage4"],    A=[2, 3, 4],    A=None,    ):

									"""simple docstring"""


									lowerCamelCase					:			Optional[Any]									= parent
									lowerCamelCase					:			Union[str, Any]									= batch_size
									lowerCamelCase					:			Optional[int]									= image_size
									lowerCamelCase					:			Any									= num_channels
									lowerCamelCase					:			Any									= num_stages
									lowerCamelCase					:			str									= hidden_sizes
									lowerCamelCase					:			Dict									= depths
									lowerCamelCase					:			Optional[int]									= is_training
									lowerCamelCase					:			str									= use_labels
									lowerCamelCase					:			str									= intermediate_size
									lowerCamelCase					:			List[str]									= hidden_act
									lowerCamelCase					:			Tuple									= num_labels
									lowerCamelCase					:			Tuple									= initializer_range
									lowerCamelCase					:			Tuple									= out_features
									lowerCamelCase					:			List[str]									= out_indices
									lowerCamelCase					:			int									= scope
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			str									= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

									lowerCamelCase					:			Tuple									= None
									if self.use_labels:
													lowerCamelCase					:			Tuple									= ids_tensor([self.batch_size],    self.num_labels      )

									lowerCamelCase					:			Dict									= 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=A,    initializer_range=self.initializer_range,    out_features=self.out_features,    out_indices=self.out_indices,    num_labels=self.num_labels,    )
					def     UpperCAmelCase_							(     self,    A,    A,    A      ):

									"""simple docstring"""


									lowerCamelCase					:			Dict									= ConvNextModel(config=A      )
									model.to(A      )
									model.eval()
									lowerCamelCase					:			Optional[Any]									= model(A      )
									# 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,    A,    A,    A      ):

									"""simple docstring"""


									lowerCamelCase					:			int									= ConvNextForImageClassification(A      )
									model.to(A      )
									model.eval()
									lowerCamelCase					:			int									= model(A,    labels=A      )
									self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_labels)      )
					def     UpperCAmelCase_							(     self,    A,    A,    A      ):

									"""simple docstring"""


									lowerCamelCase					:			List[str]									= ConvNextBackbone(config=A      )
									model.to(A      )
									model.eval()
									lowerCamelCase					:			List[str]									= model(A      )

									# verify hidden states
									self.parent.assertEqual(len(result.feature_maps      ),    len(config.out_features      )      )
									self.parent.assertListEqual(list(result.feature_maps[0].shape      ),    [self.batch_size, self.hidden_sizes[1], 4, 4]      )

									# verify channels
									self.parent.assertEqual(len(model.channels      ),    len(config.out_features      )      )
									self.parent.assertListEqual(model.channels,    config.hidden_sizes[1:]      )

									# verify backbone works with out_features=None
									lowerCamelCase					:			Dict									= None
									lowerCamelCase					:			str									= ConvNextBackbone(config=A      )
									model.to(A      )
									model.eval()
									lowerCamelCase					:			Union[str, Any]									= model(A      )

									# verify feature maps
									self.parent.assertEqual(len(result.feature_maps      ),    1      )
									self.parent.assertListEqual(list(result.feature_maps[0].shape      ),    [self.batch_size, self.hidden_sizes[-1], 1, 1]      )

									# verify channels
									self.parent.assertEqual(len(model.channels      ),    1      )
									self.parent.assertListEqual(model.channels,    [config.hidden_sizes[-1]]      )




					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			str									= self.prepare_config_and_inputs()
									lowerCamelCase			, lowerCamelCase			, lowerCamelCase					:			Tuple									= config_and_inputs
									lowerCamelCase					:			Any									= {'pixel_values': pixel_values}
									return config, inputs_dict





@require_torch
class     __snake_case		(   a__    ,   a__    ,   unittest.TestCase):
					_lowerCAmelCase			     =	(
					    (
					        ConvNextModel,
					        ConvNextForImageClassification,
					        ConvNextBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					_lowerCAmelCase			     =	(
					    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
					    if is_torch_available()
					    else {}
					)

					_lowerCAmelCase			     =	True
					_lowerCAmelCase			     =	False
					_lowerCAmelCase			     =	False
					_lowerCAmelCase			     =	False
					_lowerCAmelCase			     =	False
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			Optional[int]									= ConvNextModelTester(self      )
									lowerCamelCase					:			Union[str, Any]									= ConfigTester(self,    config_class=A,    has_text_modality=A,    hidden_size=37      )
					def     UpperCAmelCase_							(     self      ):

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

									"""simple docstring"""


									return
					@unittest.skip(reason='ConvNext does not use inputs_embeds'      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									pass
					@unittest.skip(reason='ConvNext does not support input and output embeddings'      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									pass
					@unittest.skip(reason='ConvNext does not use feedforward chunking'      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									pass
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


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

									for model_class in self.all_model_classes:
													lowerCamelCase					:			Tuple									= model_class(A      )
													lowerCamelCase					:			List[Any]									= inspect.signature(model.forward      )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													lowerCamelCase					:			Tuple									= [*signature.parameters.keys()]

													lowerCamelCase					:			int									= ['pixel_values']
													self.assertListEqual(arg_names[:1],    A      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[str]									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*A      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[Any]									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*A      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									def check_hidden_states_output(A,    A,    A      ):
													lowerCamelCase					:			Any									= model_class(A      )
													model.to(A      )
													model.eval()

													with torch.no_grad():
																	lowerCamelCase					:			str									= model(**self._prepare_for_class(A,    A      )      )

													lowerCamelCase					:			int									= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													lowerCamelCase					:			List[str]									= self.model_tester.num_stages
													self.assertEqual(len(A      ),    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],    )

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

									for model_class in self.all_model_classes:
													lowerCamelCase					:			int									= True
													check_hidden_states_output(A,    A,    A      )

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

													check_hidden_states_output(A,    A,    A      )
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[Any]									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*A      )




					@slow
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCamelCase					:			int									= ConvNextModel.from_pretrained(A      )
													self.assertIsNotNone(A      )





def    UpperCAmelCase							(  ):
				lowerCamelCase					:			List[str]									= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
				return image




@require_torch
@require_vision
class     __snake_case		(   unittest.TestCase):
					@cached_property
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


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




					@slow
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[Any]									= ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224'      ).to(A      )

									lowerCamelCase					:			Union[str, Any]									= self.default_image_processor
									lowerCamelCase					:			List[str]									= prepare_img()
									lowerCamelCase					:			Any									= image_processor(images=A,    return_tensors='pt'      ).to(A      )

									# forward pass
									with torch.no_grad():
													lowerCamelCase					:			List[Any]									= model(**A      )

									# verify the logits
									lowerCamelCase					:			Dict									= torch.Size((1, 1000)      )
									self.assertEqual(outputs.logits.shape,    A      )

									lowerCamelCase					:			List[str]									= torch.tensor([-0.0260, -0.4739, 0.1911]      ).to(A      )

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





@require_torch
class     __snake_case		(   unittest.TestCase    ,   a__):
					_lowerCAmelCase			     =	(ConvNextBackbone,) if is_torch_available() else ()
					_lowerCAmelCase			     =	ConvNextConfig

					_lowerCAmelCase			     =	False
					def     UpperCAmelCase_							(     self      ):

									"""simple docstring"""


									lowerCamelCase					:			List[Any]									= ConvNextModelTester(self      )


'''simple docstring'''






def    UpperCAmelCase							(  UpperCAmelCase__							:							list[int]):
				if not nums:  # Makes sure that the list is not empty
								raise ValueError('List is empty')

				lowerCamelCase					:			int									= sum(UpperCAmelCase__) / len(UpperCAmelCase__)  # Calculate the average
				return sum(abs(x - average) for x in nums) / len(UpperCAmelCase__)


if __name__ == "__main__":
					import doctest

					doctest.testmod()
