





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_ :





					"""simple docstring"""


					def __init__( self	,  _lowerCAmelCase	,  _lowerCAmelCase=3	,  _lowerCAmelCase=32	,  _lowerCAmelCase=3	,  _lowerCAmelCase=10	,  _lowerCAmelCase=[10, 20, 30, 40]	,  _lowerCAmelCase=[1, 1, 2, 1]	,  _lowerCAmelCase=True	,  _lowerCAmelCase=True	,  _lowerCAmelCase="relu"	,  _lowerCAmelCase=3	,  _lowerCAmelCase=None	,  ):
										lowerCamelCase__       =       parent
										lowerCamelCase__       =       batch_size
										lowerCamelCase__       =       image_size
										lowerCamelCase__       =       num_channels
										lowerCamelCase__       =       embeddings_size
										lowerCamelCase__       =       hidden_sizes
										lowerCamelCase__       =       depths
										lowerCamelCase__       =       is_training
										lowerCamelCase__       =       use_labels
										lowerCamelCase__       =       hidden_act
										lowerCamelCase__       =       num_labels
										lowerCamelCase__       =       scope
										lowerCamelCase__       =       len(_lowerCAmelCase	)





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

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

										lowerCamelCase__       =       self.get_config()

										return config, pixel_values, labels





					def 					__magic_name__ ( self	):
										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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       RegNetModel(config=_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(_lowerCAmelCase	)
										# 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 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.num_labels
										lowerCamelCase__       =       RegNetForImageClassification(_lowerCAmelCase	)
										model.to(_lowerCAmelCase	)
										model.eval()
										lowerCamelCase__       =       model(_lowerCAmelCase	,  labels=_lowerCAmelCase	)
										self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.num_labels)	)






					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.prepare_config_and_inputs()
										lowerCamelCase__    ,		lowerCamelCase__    ,		lowerCamelCase__       =       config_and_inputs
										lowerCamelCase__       =       {"pixel_values": pixel_values}
										return config, inputs_dict

@require_torch
class SCREAMING_SNAKE_CASE_ (					lowercase_							,       lowercase_							,       unittest.TestCase   ):





					"""simple docstring"""


					A__     :   Dict				 =    (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
					A__     :   Any				 =    (
					    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
					    if is_torch_available()
					    else {}
					)

					A__     :   Dict				 =    False
					A__     :   Tuple				 =    False
					A__     :   List[str]				 =    False
					A__     :   Dict				 =    False





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       RegNetModelTester(self	)
										lowerCamelCase__       =       ConfigTester(self	,  config_class=_lowerCAmelCase	,  has_text_modality=_lowerCAmelCase	)





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





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





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





					def 					__magic_name__ ( self	):
										lowerCamelCase__    ,		lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()

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

															lowerCamelCase__       =       ["pixel_values"]
															self.assertListEqual(arg_names[:1]	,  _lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__    ,		lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()

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

															with torch.no_grad():
																				lowerCamelCase__       =       model(**self._prepare_for_class(_lowerCAmelCase	,  _lowerCAmelCase	)	)

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

															lowerCamelCase__       =       self.model_tester.num_stages
															self.assertEqual(len(_lowerCAmelCase	)	,  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__    ,		lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs_for_common()
										lowerCamelCase__       =       ["basic", "bottleneck"]
										for model_class in self.all_model_classes:
															for layer_type in layers_type:
																				lowerCamelCase__       =       layer_type
																				lowerCamelCase__       =       True
																				check_hidden_states_output(_lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	)

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

																				check_hidden_states_output(_lowerCAmelCase	,  _lowerCAmelCase	,  _lowerCAmelCase	)





					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase	)






					@slow
					def 					__magic_name__ ( self	):
										for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowerCamelCase__       =       RegNetModel.from_pretrained(_lowerCAmelCase	)
															self.assertIsNotNone(_lowerCAmelCase	)





def    __UpperCamelCase      (    ) ->str:
					lowerCamelCase__       =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
					return image







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





					"""simple docstring"""


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






					@slow
					def 					__magic_name__ ( self	):
										lowerCamelCase__       =       RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(_lowerCAmelCase	)

										lowerCamelCase__       =       self.default_image_processor
										lowerCamelCase__       =       prepare_img()
										lowerCamelCase__       =       image_processor(images=_lowerCAmelCase	,  return_tensors="pt"	).to(_lowerCAmelCase	)

										# forward pass
										with torch.no_grad():
															lowerCamelCase__       =       model(**_lowerCAmelCase	)

										# verify the logits
										lowerCamelCase__       =       torch.Size((1, 1000)	)
										self.assertEqual(outputs.logits.shape	,  _lowerCAmelCase	)

										lowerCamelCase__       =       torch.tensor([-0.4_180, -1.5_051, -3.4_836]	).to(_lowerCAmelCase	)

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








A_												=     {str(digit): digit**5 for digit in range(1_0)}





def    __UpperCamelCase      (    a) ->int:
					return sum(DIGITS_FIFTH_POWER[digit] for digit in str(a))





def    __UpperCamelCase      (    ) ->int:
					return sum(
					    number
					    for number in range(1000,     1000000)
					    if number == digits_fifth_powers_sum(a))


if __name__ == "__main__":
						print(solution())

