



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



						def __init__(self						,     _lowercase						,     _lowercase=3						,     _lowercase=32						,     _lowercase=3						,     _lowercase=10						,     _lowercase=[10, 20, 30, 40]						,     _lowercase=[1, 1, 2, 1]						,     _lowercase=True						,     _lowercase=True						,     _lowercase="relu"						,     _lowercase=3						,     _lowercase=None						,     ):





													'''simple docstring'''

													__a		:		Tuple									=       parent
													__a		:		str									=       batch_size
													__a		:		Any									=       image_size
													__a		:		int									=       num_channels
													__a		:		Union[str, Any]									=       embeddings_size
													__a		:		int									=       hidden_sizes
													__a		:		Any									=       depths
													__a		:		List[str]									=       is_training
													__a		:		int									=       use_labels
													__a		:		int									=       hidden_act
													__a		:		Optional[int]									=       num_labels
													__a		:		int									=       scope
													__a		:		List[Any]									=       len(_lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[str]									=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

													__a		:		Tuple									=       self.get_config()

													return config, pixel_values, labels



						def     lowerCAmelCase__(self							):





													'''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     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

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





													'''simple docstring'''

													__a		:		Tuple									=       self.num_labels
													__a		:		List[str]									=       RegNetForImageClassification(_lowercase							)
													model.to(_lowercase							)
													model.eval()
													__a		:		Tuple									=       model(_lowercase						,     labels=_lowercase							)
													self.parent.assertEqual(result.logits.shape						,     (self.batch_size, self.num_labels)							)





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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







@require_torch
class SCREAMING_SNAKE_CASE__					(		__snake_case     ,					__snake_case     ,					unittest.TestCase      ):
						_lowerCAmelCase							=					(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
						_lowerCAmelCase							=					(
						    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

						_lowerCAmelCase							=					False
						_lowerCAmelCase							=					False
						_lowerCAmelCase							=					False
						_lowerCAmelCase							=					False



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		str									=       RegNetModelTester(self							)
													__a		:		Any									=       ConfigTester(self						,     config_class=_lowercase						,     has_text_modality=_lowercase							)



						def     lowerCAmelCase__(self							):





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





													'''simple docstring'''

													return



						@unittest.skip(reason="""RegNet does not use inputs_embeds"""							)
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													pass



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





													'''simple docstring'''

													pass



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Tuple									=       self.model_tester.prepare_config_and_inputs_for_common()

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

																				__a		:		int									=       ["""pixel_values"""]
																				self.assertListEqual(arg_names[:1]						,     _lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[Any]									=       self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*_lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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

													for model_class in self.all_model_classes:
																				__a		:		Dict									=       model_class(config=_lowercase							)
																				for name, module in model.named_modules():
																											if isinstance(_lowercase						,     (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							):





													'''simple docstring'''

													def check_hidden_states_output(_lowercase						,     _lowercase						,     _lowercase							):
																				__a		:		str									=       model_class(_lowercase							)
																				model.to(_lowercase							)
																				model.eval()

																				with torch.no_grad():
																											__a		:		Optional[Any]									=       model(**self._prepare_for_class(_lowercase						,     _lowercase							)							)

																				__a		:		str									=       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																				__a		:		Dict									=       self.model_tester.num_stages
																				self.assertEqual(len(_lowercase							)						,     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		:		Tuple									=       self.model_tester.prepare_config_and_inputs_for_common()
													__a		:		Any									=       ["""basic""", """bottleneck"""]
													for model_class in self.all_model_classes:
																				for layer_type in layers_type:
																											__a		:		int									=       layer_type
																											__a		:		List[str]									=       True
																											check_hidden_states_output(_lowercase						,     _lowercase						,     _lowercase							)

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

																											check_hidden_states_output(_lowercase						,     _lowercase						,     _lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		str									=       self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*_lowercase							)





						@slow
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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







def       __magic_name__    (   ):
							__a		:		List[Any]									=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
							return image







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



						@cached_property
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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





						@slow
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[str]									=       RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(_lowercase							)

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

													# forward pass
													with torch.no_grad():
																				__a		:		Optional[Any]									=       model(**_lowercase							)

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

													__a		:		Optional[Any]									=       torch.tensor([-0.4180, -1.5051, -3.4836]							).to(_lowercase							)

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






"""simple docstring"""

def       __magic_name__    (   _lowerCamelCase				: int  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float(moles / volume					) * nfactor					)





def       __magic_name__    (   _lowerCamelCase				: float  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float((moles * 0.08_21 * temperature) / (volume)					)					)





def       __magic_name__    (   _lowerCamelCase				: float  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float((moles * 0.08_21 * temperature) / (pressure)					)					)





def       __magic_name__    (   _lowerCamelCase				: float  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float((pressure * volume) / (0.08_21 * moles)					)					)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

