





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







					'''simple docstring'''




					def __init__(    self						,      _UpperCAmelCase						,      _UpperCAmelCase=13						,      _UpperCAmelCase=32						,      _UpperCAmelCase=3						,      _UpperCAmelCase=4						,      _UpperCAmelCase=[10, 20, 30, 40]						,      _UpperCAmelCase=[2, 2, 3, 2]						,      _UpperCAmelCase=True						,      _UpperCAmelCase=True						,      _UpperCAmelCase=37						,      _UpperCAmelCase="gelu"						,      _UpperCAmelCase=10						,      _UpperCAmelCase=0.0_2						,      _UpperCAmelCase=["stage2", "stage3", "stage4"]						,      _UpperCAmelCase=[2, 3, 4]						,      _UpperCAmelCase=None						,      ):
									__a			:    Tuple      							=	parent
									__a			:    Optional[Any]      							=	batch_size
									__a			:    List[Any]      							=	image_size
									__a			:    Optional[int]      							=	num_channels
									__a			:    int      							=	num_stages
									__a			:    List[str]      							=	hidden_sizes
									__a			:    Tuple      							=	depths
									__a			:    Union[str, Any]      							=	is_training
									__a			:    Optional[int]      							=	use_labels
									__a			:    Union[str, Any]      							=	intermediate_size
									__a			:    str      							=	hidden_act
									__a			:    List[str]      							=	num_labels
									__a			:    Union[str, Any]      							=	initializer_range
									__a			:    Dict      							=	out_features
									__a			:    Union[str, Any]      							=	out_indices
									__a			:    Optional[int]      							=	scope







					def 			_lowerCamelCase		(    self  ):
									__a			:    Any      							=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

									__a			:    Optional[int]      							=	None
									if self.use_labels:
													__a			:    Dict      							=	ids_tensor([self.batch_size]						,      self.num_labels  )

									__a			:    Optional[Any]      							=	self.get_config()
									return config, pixel_values, labels







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







					def 			_lowerCamelCase		(    self						,      _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase  ):
									__a			:    Optional[int]      							=	ConvNextModel(config=_UpperCAmelCase  )
									model.to(_UpperCAmelCase  )
									model.eval()
									__a			:    Tuple      							=	model(_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						,      _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase  ):
									__a			:    int      							=	ConvNextForImageClassification(_UpperCAmelCase  )
									model.to(_UpperCAmelCase  )
									model.eval()
									__a			:    List[Any]      							=	model(_UpperCAmelCase						,      labels=_UpperCAmelCase  )
									self.parent.assertEqual(result.logits.shape						,      (self.batch_size, self.num_labels)  )







					def 			_lowerCamelCase		(    self						,      _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase  ):
									__a			:    Optional[Any]      							=	ConvNextBackbone(config=_UpperCAmelCase  )
									model.to(_UpperCAmelCase  )
									model.eval()
									__a			:    List[str]      							=	model(_UpperCAmelCase  )

									# 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
									__a			:    List[str]      							=	None
									__a			:    Union[str, Any]      							=	ConvNextBackbone(config=_UpperCAmelCase  )
									model.to(_UpperCAmelCase  )
									model.eval()
									__a			:    List[str]      							=	model(_UpperCAmelCase  )

									# 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 			_lowerCamelCase		(    self  ):
									__a			:    List[str]      							=	self.prepare_config_and_inputs()
									__a							,    __a							,    __a			:    int      							=	config_and_inputs
									__a			:    int      							=	{'''pixel_values''': pixel_values}
									return config, inputs_dict






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







					'''simple docstring'''




					__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 			_lowerCamelCase		(    self  ):
									__a			:    Optional[int]      							=	ConvNextModelTester(self  )
									__a			:    List[str]      							=	ConfigTester(self						,      config_class=_UpperCAmelCase						,      has_text_modality=_UpperCAmelCase						,      hidden_size=37  )







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







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







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







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







					def 			_lowerCamelCase		(    self  ):
									__a							,    __a			:    int      							=	self.model_tester.prepare_config_and_inputs_for_common()

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

													__a			:    List[Any]      							=	['''pixel_values''']
													self.assertListEqual(arg_names[:1]						,      _UpperCAmelCase  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    List[Any]      							=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCAmelCase  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    Union[str, Any]      							=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_backbone(*_UpperCAmelCase  )







					def 			_lowerCamelCase		(    self  ):
									def check_hidden_states_output(_UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase  ):
													__a			:    Tuple      							=	model_class(_UpperCAmelCase  )
													model.to(_UpperCAmelCase  )
													model.eval()

													with torch.no_grad():
																	__a			:    str      							=	model(**self._prepare_for_class(_UpperCAmelCase						,      _UpperCAmelCase  )  )

													__a			:    List[Any]      							=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__a			:    Optional[int]      							=	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			:    Dict      							=	self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													__a			:    List[Any]      							=	True
													check_hidden_states_output(_UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase  )

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

													check_hidden_states_output(_UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase  )







					def 			_lowerCamelCase		(    self  ):
									__a			:    str      							=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase  )







					@slow
					def 			_lowerCamelCase		(    self  ):
									for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__a			:    Any      							=	ConvNextModel.from_pretrained(_UpperCAmelCase  )
													self.assertIsNotNone(_UpperCAmelCase  )






def      __A   (      )		->		Any:
				__a			:    Tuple      							=	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
				return image




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







					'''simple docstring'''




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







					@slow
					def 			_lowerCamelCase		(    self  ):
									__a			:    Optional[Any]      							=	ConvNextForImageClassification.from_pretrained('''facebook/convnext-tiny-224'''  ).to(_UpperCAmelCase  )

									__a			:    Optional[Any]      							=	self.default_image_processor
									__a			:    Optional[Any]      							=	prepare_img()
									__a			:    List[str]      							=	image_processor(images=_UpperCAmelCase						,      return_tensors='''pt'''  ).to(_UpperCAmelCase  )

									# forward pass
									with torch.no_grad():
													__a			:    int      							=	model(**_UpperCAmelCase  )

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

									__a			:    int      							=	torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]  ).to(_UpperCAmelCase  )

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






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







					'''simple docstring'''




					__lowerCAmelCase	=	(ConvNextBackbone,) if is_torch_available() else ()
					__lowerCAmelCase	=	ConvNextConfig

					__lowerCAmelCase	=	False







					def 			_lowerCamelCase		(    self  ):
									__a			:    Tuple      							=	ConvNextModelTester(self  )

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


lowercase    :   List[str]						=			{
    'configuration_gpt_bigcode': ['GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTBigCodeConfig'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase    :   List[str]						=			[
		    'GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'GPTBigCodeForSequenceClassification',
		    'GPTBigCodeForTokenClassification',
		    'GPTBigCodeForCausalLM',
		    'GPTBigCodeModel',
		    'GPTBigCodePreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_gpt_bigcode import (
				    GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
				    GPTBigCodeForCausalLM,
				    GPTBigCodeForSequenceClassification,
				    GPTBigCodeForTokenClassification,
				    GPTBigCodeModel,
				    GPTBigCodePreTrainedModel,
				)


else:
		import sys

		lowercase    :   Tuple						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)