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






						def __init__(				self					:	Any							,    UpperCAmelCase					:	Any							,    UpperCAmelCase					:	Dict=3							,    UpperCAmelCase					:	Dict=32							,    UpperCAmelCase					:	Tuple=3							,    UpperCAmelCase					:	str=10							,    UpperCAmelCase					:	str=[10, 20, 30, 40]							,    UpperCAmelCase					:	Optional[int]=[1, 1, 2, 1]							,    UpperCAmelCase					:	Dict=True							,    UpperCAmelCase					:	int=True							,    UpperCAmelCase					:	int="relu"							,    UpperCAmelCase					:	Union[str, Any]=3							,    UpperCAmelCase					:	List[Any]=None							,    ):
													__lowerCamelCase    :						Any						      =   parent
													__lowerCamelCase    :						int						      =   batch_size
													__lowerCamelCase    :						List[str]						      =   image_size
													__lowerCamelCase    :						Any						      =   num_channels
													__lowerCamelCase    :						List[Any]						      =   embeddings_size
													__lowerCamelCase    :						Dict						      =   hidden_sizes
													__lowerCamelCase    :						List[str]						      =   depths
													__lowerCamelCase    :						int						      =   is_training
													__lowerCamelCase    :						Union[str, Any]						      =   use_labels
													__lowerCamelCase    :						List[Any]						      =   hidden_act
													__lowerCamelCase    :						Optional[int]						      =   num_labels
													__lowerCamelCase    :						List[Any]						      =   scope
													__lowerCamelCase    :						Optional[Any]						      =   len(UpperCamelCase__			)






						def 					lowerCamelCase__   (				self					:	Any			):
													__lowerCamelCase    :						Any						      =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

													__lowerCamelCase    :						Union[str, Any]						      =   None
													if self.use_labels:
																				__lowerCamelCase    :						Optional[Any]						      =   ids_tensor([self.batch_size]							,    self.num_labels			)

													__lowerCamelCase    :						List[Any]						      =   self.get_config()

													return config, pixel_values, labels






						def 					lowerCamelCase__   (				self					:	Optional[int]			):
													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 					lowerCamelCase__   (				self					:	Optional[int]							,    UpperCAmelCase					:	List[Any]							,    UpperCAmelCase					:	str							,    UpperCAmelCase					:	str			):
													__lowerCamelCase    :						List[str]						      =   RegNetModel(config=UpperCamelCase__			)
													model.to(UpperCamelCase__			)
													model.eval()
													__lowerCamelCase    :						Optional[int]						      =   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					:	Optional[Any]							,    UpperCAmelCase					:	Dict							,    UpperCAmelCase					:	Optional[int]							,    UpperCAmelCase					:	Any			):
													__lowerCamelCase    :						List[str]						      =   self.num_labels
													__lowerCamelCase    :						List[Any]						      =   RegNetForImageClassification(UpperCamelCase__			)
													model.to(UpperCamelCase__			)
													model.eval()
													__lowerCamelCase    :						Tuple						      =   model(UpperCamelCase__							,    labels=UpperCamelCase__			)
													self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)			)







						def 					lowerCamelCase__   (				self					:	Optional[Any]			):
													__lowerCamelCase    :						Union[str, Any]						      =   self.prepare_config_and_inputs()
													__lowerCamelCase    :						Tuple						      =   config_and_inputs
													__lowerCamelCase    :						Union[str, Any]						      =   {"pixel_values": pixel_values}
													return config, inputs_dict

@require_torch
class        _snake_case   (    snake_case_ ,       snake_case_ ,       unittest.TestCase						):
						snake_case__	     =	(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
						snake_case__	     =	(
						    {'''feature-extraction''': RegNetModel, '''image-classification''': RegNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

						snake_case__	     =	False
						snake_case__	     =	False
						snake_case__	     =	False
						snake_case__	     =	False






						def 					lowerCamelCase__   (				self					:	Tuple			):
													__lowerCamelCase    :						Optional[int]						      =   RegNetModelTester(self			)
													__lowerCamelCase    :						List[str]						      =   ConfigTester(self							,    config_class=UpperCamelCase__							,    has_text_modality=UpperCamelCase__			)






						def 					lowerCamelCase__   (				self					:	List[str]			):
													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					:	Dict			):
													return






						@unittest.skip(reason="RegNet does not use inputs_embeds"			)
						def 					lowerCamelCase__   (				self					:	Optional[int]			):
													pass






						@unittest.skip(reason="RegNet does not support input and output embeddings"			)
						def 					lowerCamelCase__   (				self					:	int			):
													pass






						def 					lowerCamelCase__   (				self					:	Union[str, Any]			):
													__lowerCamelCase    :						List[str]						      =   self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				__lowerCamelCase    :						Optional[Any]						      =   model_class(UpperCamelCase__			)
																				__lowerCamelCase    :						List[Any]						      =   inspect.signature(model.forward			)
																				# signature.parameters is an OrderedDict => so arg_names order is deterministic
																				__lowerCamelCase    :						Optional[int]						      =   [*signature.parameters.keys()]

																				__lowerCamelCase    :						Dict						      =   ["pixel_values"]
																				self.assertListEqual(arg_names[:1]							,    UpperCamelCase__			)






						def 					lowerCamelCase__   (				self					:	List[Any]			):
													__lowerCamelCase    :						List[str]						      =   self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*UpperCamelCase__			)






						def 					lowerCamelCase__   (				self					:	Dict			):
													__lowerCamelCase    :						List[Any]						      =   self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				__lowerCamelCase    :						str						      =   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 					lowerCamelCase__   (				self					:	List[str]			):




													def check_hidden_states_output(UpperCAmelCase					:	Tuple							,    UpperCAmelCase					:	Optional[int]							,    UpperCAmelCase					:	List[str]			):
																				__lowerCamelCase    :						List[str]						      =   model_class(UpperCamelCase__			)
																				model.to(UpperCamelCase__			)
																				model.eval()

																				with torch.no_grad():
																											__lowerCamelCase    :						Tuple						      =   model(**self._prepare_for_class(UpperCamelCase__							,    UpperCamelCase__			)			)

																				__lowerCamelCase    :						List[str]						      =   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				__lowerCamelCase    :						Optional[int]						      =   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]							,    )

													__lowerCamelCase    :						Optional[int]						      =   self.model_tester.prepare_config_and_inputs_for_common()
													__lowerCamelCase    :						List[str]						      =   ["basic", "bottleneck"]
													for model_class in self.all_model_classes:
																				for layer_type in layers_type:
																											__lowerCamelCase    :						Optional[Any]						      =   layer_type
																											__lowerCamelCase    :						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"]
																											__lowerCamelCase    :						Optional[Any]						      =   True

																											check_hidden_states_output(UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__			)






						def 					lowerCamelCase__   (				self					:	List[str]			):
													__lowerCamelCase    :						Any						      =   self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__			)







						@slow
						def 					lowerCamelCase__   (				self					:	Union[str, Any]			):




													for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__lowerCamelCase    :						str						      =   RegNetModel.from_pretrained(UpperCamelCase__			)
																				self.assertIsNotNone(UpperCamelCase__			)


def       lowercase_      (      )       ->					List[Any]:



							'''simple docstring'''

							__lowerCamelCase    :						Optional[Any]						      =   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
							return image







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






						@cached_property
						def 					lowerCamelCase__   (				self					:	List[str]			):
													return (
													    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
													    if is_vision_available()
													    else None
													)







						@slow
						def 					lowerCamelCase__   (				self					:	Any			):
													__lowerCamelCase    :						int						      =   RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(UpperCamelCase__			)

													__lowerCamelCase    :						List[Any]						      =   self.default_image_processor
													__lowerCamelCase    :						List[Any]						      =   prepare_img()
													__lowerCamelCase    :						Optional[Any]						      =   image_processor(images=UpperCamelCase__							,    return_tensors="pt"			).to(UpperCamelCase__			)

													# forward pass
													with torch.no_grad():
																				__lowerCamelCase    :						Any						      =   model(**UpperCamelCase__			)

													# verify the logits
													__lowerCamelCase    :						Optional[int]						      =   torch.Size((1, 1000)			)
													self.assertEqual(outputs.logits.shape							,    UpperCamelCase__			)

													__lowerCamelCase    :						Any						      =   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"""



from typing import Dict

from .base import GenericTensor, Pipeline







class _lowerCAmelCase				(      snake_case_	):







   def  lowerCamelCase		(	self						,	UpperCamelCase__=None						,	UpperCamelCase__=None						,	UpperCamelCase__=None						,	**UpperCamelCase__						)	->		Union[str, Any]:

       '''simple docstring'''




       if tokenize_kwargs is None:
           snake_case    :      Optional[Any]      					=    {}

       if truncation is not None:
           if "truncation" in tokenize_kwargs:
               raise ValueError(
                   "truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)"						)
           snake_case    :      List[str]      					=    truncation

       snake_case    :      Union[str, Any]      					=    tokenize_kwargs

       snake_case    :      List[Any]      					=    {}
       if return_tensors is not None:
           snake_case    :      Tuple      					=    return_tensors

       return preprocess_params, {}, postprocess_params







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	**UpperCamelCase__						)	->		Dict[str, GenericTensor]:

       '''simple docstring'''




       snake_case    :      List[Any]      					=    self.framework
       snake_case    :      str      					=    self.tokenizer(UpperCamelCase__						,	return_tensors=UpperCamelCase__						,	**UpperCamelCase__						)
       return model_inputs







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Tuple:

       '''simple docstring'''




       snake_case    :      int      					=    self.model(**UpperCamelCase__						)
       return model_outputs







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__=False						)	->		Union[str, Any]:

       '''simple docstring'''




       if return_tensors:
           return model_outputs[0]
       if self.framework == "pt":
           return model_outputs[0].tolist()
       elif self.framework == "tf":
           return model_outputs[0].numpy().tolist()







   def __call__(	self						,	*UpperCamelCase__						,	**UpperCamelCase__						)	->		Union[str, Any]:

       '''simple docstring'''




       return super().__call__(*UpperCamelCase__						,	**UpperCamelCase__						)





