"""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		,__UpperCAmelCase		,__UpperCAmelCase=3		,__UpperCAmelCase=32		,__UpperCAmelCase=3		,__UpperCAmelCase=10		,__UpperCAmelCase=[10, 20, 30, 40]		,__UpperCAmelCase=[1, 1, 2, 1]		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase="relu"		,__UpperCAmelCase=3		,__UpperCAmelCase=None		,)					->				List[str]:
													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(__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Union[str, Any]:
													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 				snake_case__	(       self     )					->				List[Any]:
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				int:
													A__	     =							RegNetModel(config=__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				List[Any]:
													A__	     =							self.num_labels
													A__	     =							RegNetForImageClassification(__UpperCAmelCase     )
													model.to(__UpperCAmelCase     )
													model.eval()
													A__	     =							model(__UpperCAmelCase		,labels=__UpperCAmelCase     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)     )





						def 				snake_case__	(       self     )					->				Tuple:
													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__(			__A		,						__A		,						unittest.TestCase ):
						lowerCAmelCase__  :						int													=		(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
						lowerCAmelCase__  :						List[Any]													=		(
						    {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

						lowerCAmelCase__  :						Optional[Any]													=		False
						lowerCAmelCase__  :						Tuple													=		False
						lowerCAmelCase__  :						Optional[int]													=		False
						lowerCAmelCase__  :						List[str]													=		False





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =							RegNetModelTester(self     )
													A__	     =							ConfigTester(self		,config_class=__UpperCAmelCase		,has_text_modality=__UpperCAmelCase     )





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





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





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





						def 				snake_case__	(       self     )					->				Dict:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__	     =							model_class(__UpperCAmelCase     )
																				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]		,__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Optional[int]:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Any:
													A__     ,  A__	     =							self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__	     =							model_class(config=__UpperCAmelCase     )
																				for name, module in model.named_modules():
																											if isinstance(__UpperCAmelCase		,(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 				snake_case__	(       self     )					->				Dict:
													def check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     ):
																				A__	     =							model_class(__UpperCAmelCase     )
																				model.to(__UpperCAmelCase     )
																				model.eval()

																				with torch.no_grad():
																											A__	     =							model(**self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase     )     )

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

																				A__	     =							self.model_tester.num_stages
																				self.assertEqual(len(__UpperCAmelCase     )		,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(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )

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

																											check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )





						def 				snake_case__	(       self     )					->				Dict:
													A__	     =							self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase     )





						@slow
						def 				snake_case__	(       self     )					->				Optional[Any]:
													for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__	     =							RegNetModel.from_pretrained(__UpperCAmelCase     )
																				self.assertIsNotNone(__UpperCAmelCase     )






def   UpperCAmelCase					(	):






							"""simple docstring"""





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


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





						@cached_property
						def 				snake_case__	(       self     )					->				Optional[Any]:
													return (
													    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
													    if is_vision_available()
													    else None
													)





						@slow
						def 				snake_case__	(       self     )					->				List[Any]:
													A__	     =							RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(__UpperCAmelCase     )

													A__	     =							self.default_image_processor
													A__	     =							prepare_img()
													A__	     =							image_processor(images=__UpperCAmelCase		,return_tensors='pt'     ).to(__UpperCAmelCase     )

													# forward pass
													with torch.no_grad():
																				A__	     =							model(**__UpperCAmelCase     )

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

													A__	     =							torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]     ).to(__UpperCAmelCase     )

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






"""simple docstring"""




import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
__lowerCamelCase											=  "."


if __name__ == "__main__":
				__lowerCamelCase											=  os.path.join(REPO_PATH, "utils/documentation_tests.txt")
				__lowerCamelCase											=  []
				__lowerCamelCase											=  []
				with open(doctest_file_path) as fp:
								for line in fp:
												__lowerCamelCase											=  line.strip()
												__lowerCamelCase											=  os.path.join(REPO_PATH, line)
												if not (os.path.isfile(path) or os.path.isdir(path)):
																non_existent_paths.append(line)
												all_paths.append(path)
				if len(non_existent_paths) > 0:
								__lowerCamelCase											=  "\n".join(non_existent_paths)
								raise ValueError(F'''`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}''')
				if all_paths != sorted(all_paths):
								raise ValueError("Files in `utils/documentation_tests.txt` are not in alphabetical order.")





