



"""simple docstring"""







import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 torch import nn

							from transformers import RegNetForImageClassification, RegNetModel
							from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor






class      UpperCAmelCase__		:



		def __init__( self  :    List[str]      ,							snake_case  :    List[Any]      ,							snake_case  :    int=3      ,							snake_case  :    List[Any]=32      ,							snake_case  :    Union[str, Any]=3      ,							snake_case  :    Union[str, Any]=10      ,							snake_case  :    int=[10, 20, 30, 40]      ,							snake_case  :    int=[1, 1, 2, 1]      ,							snake_case  :    int=True      ,							snake_case  :    str=True      ,							snake_case  :    Union[str, Any]="relu"      ,							snake_case  :    Union[str, Any]=3      ,							snake_case  :    Any=None      ,							)			->						Tuple:






									'''simple docstring'''

									A         =					parent
									A         =					batch_size
									A         =					image_size
									A         =					num_channels
									A         =					embeddings_size
									A         =					hidden_sizes
									A         =					depths
									A         =					is_training
									A         =					use_labels
									A         =					hidden_act
									A         =					num_labels
									A         =					scope
									A         =					len(snake_case				)



		def 					A_		( self  :    Optional[int]				)			->						List[str]:






									'''simple docstring'''

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

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

									A         =					self.get_config()

									return config, pixel_values, labels



		def 					A_		( self  :    Any				)			->						Tuple:






									'''simple docstring'''

									return RegNetConfig(
									    num_channels=self.num_channels      ,							embeddings_size=self.embeddings_size      ,							hidden_sizes=self.hidden_sizes      ,							depths=self.depths      ,							hidden_act=self.hidden_act      ,							num_labels=self.num_labels      ,							)



		def 					A_		( self  :    List[str]      ,							snake_case  :    str      ,							snake_case  :    Any      ,							snake_case  :    Tuple				)			->						Optional[Any]:






									'''simple docstring'''

									A         =					RegNetModel(config=snake_case				)
									model.to(snake_case				)
									model.eval()
									A         =					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  :    Optional[int]      ,							snake_case  :    int      ,							snake_case  :    List[Any]      ,							snake_case  :    Optional[Any]				)			->						Dict:






									'''simple docstring'''

									A         =					self.num_labels
									A         =					RegNetForImageClassification(snake_case				)
									model.to(snake_case				)
									model.eval()
									A         =					model(snake_case      ,							labels=snake_case				)
									self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.num_labels)				)



		def 					A_		( self  :    Tuple				)			->						Dict:






									'''simple docstring'''

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






@require_torch
class      UpperCAmelCase__		(      UpperCamelCase   ,UpperCamelCase   ,unittest.TestCase     ):
		lowerCAmelCase_       :	Optional[int] 							=     (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
		lowerCAmelCase_       :	Any 							=     (
		    {"""feature-extraction""": RegNetModel, """image-classification""": RegNetForImageClassification}
		    if is_torch_available()
		    else {}
		)

		lowerCAmelCase_       :	List[Any] 							=     False
		lowerCAmelCase_       :	Optional[Any] 							=     False
		lowerCAmelCase_       :	str 							=     False
		lowerCAmelCase_       :	Optional[int] 							=     False



		def 					A_		( self  :    str				)			->						Union[str, Any]:






									'''simple docstring'''

									A         =					RegNetModelTester(self				)
									A         =					ConfigTester(self      ,							config_class=snake_case      ,							has_text_modality=snake_case				)



		def 					A_		( self  :    List[str]				)			->						Optional[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 					A_		( self  :    Any				)			->						str:






									'''simple docstring'''

									return



		@unittest.skip(reason='RegNet does not use inputs_embeds'				)
		def 					A_		( self  :    List[str]				)			->						Dict:






									'''simple docstring'''

									pass



		@unittest.skip(reason='RegNet does not support input and output embeddings'				)
		def 					A_		( self  :    str				)			->						Optional[Any]:






									'''simple docstring'''

									pass



		def 					A_		( self  :    Any				)			->						Dict:






									'''simple docstring'''

									A      ,  A         =					self.model_tester.prepare_config_and_inputs_for_common()

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

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



		def 					A_		( self  :    str				)			->						str:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case				)



		def 					A_		( self  :    List[Any]				)			->						Tuple:






									'''simple docstring'''

									A      ,  A         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																A         =					model_class(config=snake_case				)
																for name, module in model.named_modules():
																							if isinstance(snake_case      ,							(nn.BatchNormad, nn.GroupNorm)				):
																														self.assertTrue(
																														    torch.all(module.weight == 1				)      ,							msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""      ,							)
																														self.assertTrue(
																														    torch.all(module.bias == 0				)      ,							msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""      ,							)



		def 					A_		( self  :    int				)			->						Any:






									'''simple docstring'''

									def check_hidden_states_output(snake_case  :    List[Any]      ,							snake_case  :    List[Any]      ,							snake_case  :    List[Any]				):
																A         =					model_class(snake_case				)
																model.to(snake_case				)
																model.eval()

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

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

																A         =					self.model_tester.num_stages
																self.assertEqual(len(snake_case				)      ,							expected_num_stages + 1				)

																# RegNet'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 // 2, self.model_tester.image_size // 2]      ,							)

									A      ,  A         =					self.model_tester.prepare_config_and_inputs_for_common()
									A         =					['basic', 'bottleneck']
									for model_class in self.all_model_classes:
																for layer_type in layers_type:
																							A         =					layer_type
																							A         =					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"]
																							A         =					True

																							check_hidden_states_output(snake_case      ,							snake_case      ,							snake_case				)



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






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*snake_case				)



		@slow
		def 					A_		( self  :    Optional[Any]				)			->						int:






									'''simple docstring'''

									for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																A         =					RegNetModel.from_pretrained(snake_case				)
																self.assertIsNotNone(snake_case				)



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






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



		@cached_property
		def 					A_		( self  :    Union[str, Any]				)			->						Tuple:






									'''simple docstring'''

									return (
									    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				)
									    if is_vision_available()
									    else None
									)



		@slow
		def 					A_		( self  :    Union[str, Any]				)			->						List[str]:






									'''simple docstring'''

									A         =					RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]				).to(snake_case				)

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

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

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

									A         =					torch.tensor([-0.4180, -1.5051, -3.4836]				).to(snake_case				)

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








"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


A    =			{
    'configuration_gpt_neo': ['GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTNeoConfig', 'GPTNeoOnnxConfig'],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A    =			[
							    'GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'GPTNeoForCausalLM',
							    'GPTNeoForQuestionAnswering',
							    'GPTNeoForSequenceClassification',
							    'GPTNeoForTokenClassification',
							    'GPTNeoModel',
							    'GPTNeoPreTrainedModel',
							    'load_tf_weights_in_gpt_neo',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A    =			[
							    'FlaxGPTNeoForCausalLM',
							    'FlaxGPTNeoModel',
							    'FlaxGPTNeoPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_gpt_neo import GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoConfig, GPTNeoOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_gpt_neo import (
														    GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST,
														    GPTNeoForCausalLM,
														    GPTNeoForQuestionAnswering,
														    GPTNeoForSequenceClassification,
														    GPTNeoForTokenClassification,
														    GPTNeoModel,
														    GPTNeoPreTrainedModel,
														    load_tf_weights_in_gpt_neo,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel, FlaxGPTNeoPreTrainedModel


else:
							import sys

							A    =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



