

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




				def __init__(      self   ,     snake_case   ,     snake_case=13   ,     snake_case=32   ,     snake_case=3   ,     snake_case=4   ,     snake_case=[10, 20, 30, 40]   ,     snake_case=[2, 2, 3, 2]   ,     snake_case=True   ,     snake_case=True   ,     snake_case=37   ,     snake_case="gelu"   ,     snake_case=10   ,     snake_case=0.02   ,     snake_case=["stage2", "stage3", "stage4"]   ,     snake_case=[2, 3, 4]   ,     snake_case=None   ,     ):
											snake_case_           =					parent
											snake_case_           =					batch_size
											snake_case_           =					image_size
											snake_case_           =					num_channels
											snake_case_           =					num_stages
											snake_case_           =					hidden_sizes
											snake_case_           =					depths
											snake_case_           =					is_training
											snake_case_           =					use_labels
											snake_case_           =					intermediate_size
											snake_case_           =					hidden_act
											snake_case_           =					num_labels
											snake_case_           =					initializer_range
											snake_case_           =					out_features
											snake_case_           =					out_indices
											snake_case_           =					scope




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

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

											snake_case_           =					self.get_config()
											return config, pixel_values, labels




				def 					a							(      self ):
											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=snake_case   ,     initializer_range=self.initializer_range   ,     out_features=self.out_features   ,     out_indices=self.out_indices   ,     num_labels=self.num_labels   ,     )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					ConvNextModel(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )
											# 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 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					ConvNextForImageClassification(snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case   ,     labels=snake_case )
											self.parent.assertEqual(result.logits.shape   ,     (self.batch_size, self.num_labels) )




				def 					a							(      self   ,     snake_case   ,     snake_case   ,     snake_case ):
											snake_case_           =					ConvNextBackbone(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )

											# 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
											snake_case_           =					None
											snake_case_           =					ConvNextBackbone(config=snake_case )
											model.to(snake_case )
											model.eval()
											snake_case_           =					model(snake_case )

											# 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 					a							(      self ):
											snake_case_           =					self.prepare_config_and_inputs()
											snake_case_       ,					snake_case_       ,					snake_case_           =					config_and_inputs
											snake_case_           =					{'pixel_values': pixel_values}
											return config, inputs_dict







@require_torch
class 				lowercase       ( lowercase_			,						lowercase_			,						unittest.TestCase    ):
				__SCREAMING_SNAKE_CASE      :				Optional[Any]     =    (
				    (
				        ConvNextModel,
				        ConvNextForImageClassification,
				        ConvNextBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				__SCREAMING_SNAKE_CASE      :				List[str]     =    (
				    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
				    if is_torch_available()
				    else {}
				)

				__SCREAMING_SNAKE_CASE      :				Dict     =    True
				__SCREAMING_SNAKE_CASE      :				int     =    False
				__SCREAMING_SNAKE_CASE      :				List[str]     =    False
				__SCREAMING_SNAKE_CASE      :				List[str]     =    False
				__SCREAMING_SNAKE_CASE      :				Optional[int]     =    False




				def 					a							(      self ):
											snake_case_           =					ConvNextModelTester(self )
											snake_case_           =					ConfigTester(self   ,     config_class=snake_case   ,     has_text_modality=snake_case   ,     hidden_size=37 )




				def 					a							(      self ):
											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 					a							(      self ):
											return




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




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




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




				def 					a							(      self ):
											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()

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

																		snake_case_           =					['pixel_values']
																		self.assertListEqual(arg_names[:1]   ,     snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_backbone(*snake_case )




				def 					a							(      self ):
											def check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case ):
																		snake_case_           =					model_class(snake_case )
																		model.to(snake_case )
																		model.eval()

																		with torch.no_grad():
																									snake_case_           =					model(**self._prepare_for_class(snake_case   ,     snake_case ) )

																		snake_case_           =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																		snake_case_           =					self.model_tester.num_stages
																		self.assertEqual(len(snake_case )   ,     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]   ,     )

											snake_case_       ,					snake_case_           =					self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		snake_case_           =					True
																		check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case )

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

																		check_hidden_states_output(snake_case   ,     snake_case   ,     snake_case )




				def 					a							(      self ):
											snake_case_           =					self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case )




				@slow
				def 					a							(      self ):
											for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		snake_case_           =					ConvNextModel.from_pretrained(snake_case )
																		self.assertIsNotNone(snake_case )





def       __lowerCamelCase			(				):







							'''simple docstring'''






							snake_case_           =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
							return image







@require_torch
@require_vision
class 				lowercase       ( unittest.TestCase    ):




				@cached_property
				def 					a							(      self ):
											return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None




				@slow
				def 					a							(      self ):
											snake_case_           =					ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' ).to(snake_case )

											snake_case_           =					self.default_image_processor
											snake_case_           =					prepare_img()
											snake_case_           =					image_processor(images=snake_case   ,     return_tensors='pt' ).to(snake_case )

											# forward pass
											with torch.no_grad():
																		snake_case_           =					model(**snake_case )

											# verify the logits
											snake_case_           =					torch.Size((1, 1000) )
											self.assertEqual(outputs.logits.shape   ,     snake_case )

											snake_case_           =					torch.tensor([-0.02_60, -0.47_39, 0.19_11] ).to(snake_case )

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







@require_torch
class 				lowercase       ( unittest.TestCase			,						lowercase_    ):
				__SCREAMING_SNAKE_CASE      :				Any     =    (ConvNextBackbone,) if is_torch_available() else ()
				__SCREAMING_SNAKE_CASE      :				Dict     =    ConvNextConfig

				__SCREAMING_SNAKE_CASE      :				Dict     =    False




				def 					a							(      self ):
											snake_case_           =					ConvNextModelTester(self )


from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset







class 				lowercase       ( lowercase_    ):




				def 					a							(      self ):
											return [
											    {"col_1": 3, "col_2": "a"},
											    {"col_1": 2, "col_2": "b"},
											    {"col_1": 1, "col_2": "c"},
											    {"col_1": 0, "col_2": "d"},
											]




				def 					a							(      self ):
											snake_case_           =					{'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
											return Dataset.from_dict(snake_case )




				def 					a							(      self ):
											snake_case_           =					self._create_example_records()
											snake_case_           =					Dataset.from_list(snake_case )
											self.assertListEqual(dset.column_names   ,     ['col_1', 'col_2'] )
											for i, r in enumerate(snake_case ):
																		self.assertDictEqual(snake_case   ,     example_records[i] )




				def 					a							(      self ):
											snake_case_           =					self._create_example_records()
											snake_case_           =					Dataset.from_list(snake_case )
											snake_case_           =					Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]} )
											self.assertEqual(dset.info   ,     dset_from_dict.info )




				def 					a							(      self ):  # checks what happens with missing columns
											snake_case_           =					[{'col_1': 1}, {'col_2': 'x'}]
											snake_case_           =					Dataset.from_list(snake_case )
											self.assertDictEqual(dset[0]   ,     {'col_1': 1} )
											self.assertDictEqual(dset[1]   ,     {'col_1': None} )  # NB: first record is used for columns




				def 					a							(      self ):  # checks if the type can be inferred from the second record
											snake_case_           =					[{'col_1': []}, {'col_1': [1, 2]}]
											snake_case_           =					Dataset.from_list(snake_case )
											self.assertEqual(dset.info.features['col_1']   ,     Sequence(Value('int64' ) ) )




				def 					a							(      self ):
											snake_case_           =					Dataset.from_list([] )
											self.assertEqual(len(snake_case )   ,     0 )
											self.assertListEqual(dset.column_names   ,     [] )




