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


			"""simple docstring"""






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

							'''simple docstring'''


							__lowercase					     =				parent
							__lowercase					     =				batch_size
							__lowercase					     =				image_size
							__lowercase					     =				num_channels
							__lowercase					     =				num_stages
							__lowercase					     =				hidden_sizes
							__lowercase					     =				depths
							__lowercase					     =				is_training
							__lowercase					     =				use_labels
							__lowercase					     =				intermediate_size
							__lowercase					     =				hidden_act
							__lowercase					     =				num_labels
							__lowercase					     =				initializer_range
							__lowercase					     =				out_features
							__lowercase					     =				out_indices
							__lowercase					     =				scope





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[str]:

							'''simple docstring'''


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

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

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   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=lowerCAmelCase__ ,  initializer_range=self.initializer_range ,  out_features=self.out_features ,  out_indices=self.out_indices ,  num_labels=self.num_labels ,  )





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   List[str]:

							'''simple docstring'''


							__lowercase					     =				ConvNextModel(config=lowerCAmelCase__		)
							model.to(lowerCAmelCase__		)
							model.eval()
							__lowercase					     =				model(lowerCAmelCase__		)
							# 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 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				ConvNextForImageClassification(lowerCAmelCase__		)
							model.to(lowerCAmelCase__		)
							model.eval()
							__lowercase					     =				model(lowerCAmelCase__ ,  labels=lowerCAmelCase__		)
							self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   Optional[int]:

							'''simple docstring'''


							__lowercase					     =				ConvNextBackbone(config=lowerCAmelCase__		)
							model.to(lowerCAmelCase__		)
							model.eval()
							__lowercase					     =				model(lowerCAmelCase__		)

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

							# 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 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[str]:

							'''simple docstring'''


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




@require_torch
class   _UpperCamelCase (		_UpperCAmelCase		,_UpperCAmelCase		,unittest.TestCase					):


			"""simple docstring"""






			__a    :					Any     					=		(
			    (
			        ConvNextModel,
			        ConvNextForImageClassification,
			        ConvNextBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__a    :					List[str]     					=		(
			    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
			    if is_torch_available()
			    else {}
			)

			__a    :					int     					=		True
			__a    :					List[Any]     					=		False
			__a    :					List[str]     					=		False
			__a    :					Optional[Any]     					=		False
			__a    :					Dict     					=		False





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							__lowercase					     =				ConvNextModelTester(self		)
							__lowercase					     =				ConfigTester(self ,  config_class=lowerCAmelCase__ ,  has_text_modality=lowerCAmelCase__ ,  hidden_size=37		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''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 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							return





			@unittest.skip(reason='''ConvNext does not use inputs_embeds'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


							pass





			@unittest.skip(reason='''ConvNext does not support input and output embeddings'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							pass





			@unittest.skip(reason='''ConvNext does not use feedforward chunking'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							pass





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase					     =				['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[int]:

							'''simple docstring'''


							def check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		):
											__lowercase					     =				model_class(lowerCAmelCase__		)
											model.to(lowerCAmelCase__		)
											model.eval()

											with torch.no_grad():
															__lowercase					     =				model(**self._prepare_for_class(lowerCAmelCase__ ,  lowerCAmelCase__		)		)

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

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

							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowercase					     =				True
											check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)

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

											check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__		)





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase					     =				ConvNextModel.from_pretrained(lowerCAmelCase__		)
											self.assertIsNotNone(lowerCAmelCase__		)





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



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




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


			"""simple docstring"""






			@cached_property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


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





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				ConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''		).to(lowerCAmelCase__		)

							__lowercase					     =				self.default_image_processor
							__lowercase					     =				prepare_img()
							__lowercase					     =				image_processor(images=lowerCAmelCase__ ,  return_tensors='''pt'''		).to(lowerCAmelCase__		)

							# forward pass
							with torch.no_grad():
											__lowercase					     =				model(**lowerCAmelCase__		)

							# verify the logits
							__lowercase					     =				torch.Size((1, 10_00)		)
							self.assertEqual(outputs.logits.shape ,  lowerCAmelCase__		)

							__lowercase					     =				torch.tensor([-0.0260, -0.4739, 0.1911]		).to(lowerCAmelCase__		)

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




@require_torch
class   _UpperCamelCase (		unittest.TestCase		,_UpperCAmelCase					):


			"""simple docstring"""






			__a    :					str     					=		(ConvNextBackbone,) if is_torch_available() else ()
			__a    :					Optional[Any]     					=		ConvNextConfig

			__a    :					Optional[int]     					=		False





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				ConvNextModelTester(self		)
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__a    :	List[Any]         =    logging.get_logger(__name__)

__a    :	List[Any]         =    {
    """MIT/ast-finetuned-audioset-10-10-0.4593""": (
        """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json"""
    ),
}




class   _UpperCamelCase (		_UpperCAmelCase					):


			"""simple docstring"""






			__a    :					Optional[Any]     					=		'''audio-spectrogram-transformer'''





			def __init__(  self ,  lowerCAmelCase__=7_68 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=30_72 ,  lowerCAmelCase__="gelu" ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.02 ,  lowerCAmelCase__=1E-12 ,  lowerCAmelCase__=16 ,  lowerCAmelCase__=True ,  lowerCAmelCase__=10 ,  lowerCAmelCase__=10 ,  lowerCAmelCase__=10_24 ,  lowerCAmelCase__=1_28 ,  **lowerCAmelCase__ ,  )	->   Optional[Any]:

							'''simple docstring'''


							super().__init__(**lowerCAmelCase__		)

							__lowercase					     =				hidden_size
							__lowercase					     =				num_hidden_layers
							__lowercase					     =				num_attention_heads
							__lowercase					     =				intermediate_size
							__lowercase					     =				hidden_act
							__lowercase					     =				hidden_dropout_prob
							__lowercase					     =				attention_probs_dropout_prob
							__lowercase					     =				initializer_range
							__lowercase					     =				layer_norm_eps
							__lowercase					     =				patch_size
							__lowercase					     =				qkv_bias
							__lowercase					     =				frequency_stride
							__lowercase					     =				time_stride
							__lowercase					     =				max_length
							__lowercase					     =				num_mel_bins