


import math






def 						_A						(						_lowercase				)			->				list:


					"""simple docstring"""


					if n <= 0:
										raise ValueError('Only positive integers have prime factors'				)
					__UpperCamelCase				=	[]
					while n % 2 == 0:
										pf.append(2				)
										__UpperCamelCase				=	int(n / 2				)
					for i in range(3			,       int(math.sqrt(_lowercase				)				) + 1			,       2				):
										while n % i == 0:
															pf.append(_lowercase				)
															__UpperCamelCase				=	int(n / i				)
					if n > 2:
										pf.append(_lowercase				)
					return pf






def 						_A						(						_lowercase				)			->				int:


					"""simple docstring"""


					if n <= 0:
										raise ValueError('Only positive numbers are accepted'				)
					__UpperCamelCase				=	1
					__UpperCamelCase				=	1
					while n % 2 == 0:
										temp += 1
										__UpperCamelCase				=	int(n / 2				)
					div *= temp
					for i in range(3			,       int(math.sqrt(_lowercase				)				) + 1			,       2				):
										__UpperCamelCase				=	1
										while n % i == 0:
															temp += 1
															__UpperCamelCase				=	int(n / i				)
										div *= temp
					if n > 1:
										div *= 2
					return div






def 						_A						(						_lowercase				)			->				int:


					"""simple docstring"""


					if n <= 0:
										raise ValueError('Only positive numbers are accepted'				)
					__UpperCamelCase				=	1
					__UpperCamelCase				=	1
					while n % 2 == 0:
										temp += 1
										__UpperCamelCase				=	int(n / 2				)
					if temp > 1:
										s *= (2**temp - 1) / (2 - 1)
					for i in range(3			,       int(math.sqrt(_lowercase				)				) + 1			,       2				):
										__UpperCamelCase				=	1
										while n % i == 0:
															temp += 1
															__UpperCamelCase				=	int(n / i				)
										if temp > 1:
															s *= (i**temp - 1) / (i - 1)
					return int(_lowercase				)






def 						_A						(						_lowercase				)			->				int:


					"""simple docstring"""


					__UpperCamelCase				=	n
					for x in set(prime_factors(_lowercase				)				):
										s *= (x - 1) / x
					return int(_lowercase				)


if __name__ == "__main__":
				import doctest

				doctest.testmod()






import inspect
import unittest

from transformers import ResNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 ResNetBackbone, ResNetForImageClassification, ResNetModel
    from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor



class 					__lowerCamelCase	:







       def __init__(	self:				Dict,A_:				Optional[Any],A_:				str=3,A_:				Any=32,A_:				Optional[Any]=3,A_:				Optional[Any]=10,A_:				str=[10, 20, 30, 40],A_:				Optional[int]=[1, 1, 2, 1],A_:				Dict=True,A_:				Any=True,A_:				Dict="relu",A_:				Union[str, Any]=3,A_:				Optional[int]=None,A_:				Optional[int]=["stage2", "stage3", "stage4"],A_:				Tuple=[2, 3, 4],):






            '''simple docstring'''




            __UpperCamelCase				=	parent
            __UpperCamelCase				=	batch_size
            __UpperCamelCase				=	image_size
            __UpperCamelCase				=	num_channels
            __UpperCamelCase				=	embeddings_size
            __UpperCamelCase				=	hidden_sizes
            __UpperCamelCase				=	depths
            __UpperCamelCase				=	is_training
            __UpperCamelCase				=	use_labels
            __UpperCamelCase				=	hidden_act
            __UpperCamelCase				=	num_labels
            __UpperCamelCase				=	scope
            __UpperCamelCase				=	len(A_			)
            __UpperCamelCase				=	out_features
            __UpperCamelCase				=	out_indices







       def 						snake_case_					(	self:				str			):






            '''simple docstring'''




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

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

            __UpperCamelCase				=	self.get_config()

            return config, pixel_values, labels







       def 						snake_case_					(	self:				Optional[Any]			):






            '''simple docstring'''




            return ResNetConfig(
                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,out_features=self.out_features,out_indices=self.out_indices,)







       def 						snake_case_					(	self:				Optional[int],A_:				int,A_:				Union[str, Any],A_:				List[str]			):






            '''simple docstring'''




            __UpperCamelCase				=	ResNetModel(config=A_			)
            model.to(A_			)
            model.eval()
            __UpperCamelCase				=	model(A_			)
            # 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:				int,A_:				int,A_:				List[str],A_:				Optional[Any]			):






            '''simple docstring'''




            __UpperCamelCase				=	self.num_labels
            __UpperCamelCase				=	ResNetForImageClassification(A_			)
            model.to(A_			)
            model.eval()
            __UpperCamelCase				=	model(A_,labels=A_			)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)			)







       def 						snake_case_					(	self:				Optional[Any],A_:				Any,A_:				str,A_:				Dict			):






            '''simple docstring'''




            __UpperCamelCase				=	ResNetBackbone(config=A_			)
            model.to(A_			)
            model.eval()
            __UpperCamelCase				=	model(A_			)

            # verify feature maps
            self.parent.assertEqual(len(result.feature_maps			),len(config.out_features			)			)
            self.parent.assertListEqual(list(result.feature_maps[0].shape			),[self.batch_size, self.hidden_sizes[1], 4, 4]			)

            # verify channels
            self.parent.assertEqual(len(model.channels			),len(config.out_features			)			)
            self.parent.assertListEqual(model.channels,config.hidden_sizes[1:]			)

            # verify backbone works with out_features=None
            __UpperCamelCase				=	None
            __UpperCamelCase				=	ResNetBackbone(config=A_			)
            model.to(A_			)
            model.eval()
            __UpperCamelCase				=	model(A_			)

            # verify feature maps
            self.parent.assertEqual(len(result.feature_maps			),1			)
            self.parent.assertListEqual(list(result.feature_maps[0].shape			),[self.batch_size, self.hidden_sizes[-1], 1, 1]			)

            # verify channels
            self.parent.assertEqual(len(model.channels			),1			)
            self.parent.assertListEqual(model.channels,[config.hidden_sizes[-1]]			)







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




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



@require_torch
class 					__lowerCamelCase	(_a							,     _a							,     unittest.TestCase		):
       _lowercase    							=      (
           (
               ResNetModel,
               ResNetForImageClassification,
               ResNetBackbone,
           )
           if is_torch_available()
           else ()
       )
       _lowercase    							=      (
           {"""feature-extraction""": ResNetModel, """image-classification""": ResNetForImageClassification}
           if is_torch_available()
           else {}
       )

       _lowercase    							=      True
       _lowercase    							=      False
       _lowercase    							=      False
       _lowercase    							=      False
       _lowercase    							=      False







       def 						snake_case_					(	self:				Union[str, Any]			):






            '''simple docstring'''




            __UpperCamelCase				=	ResNetModelTester(self			)
            __UpperCamelCase				=	ConfigTester(self,config_class=A_,has_text_modality=A_			)







       def 						snake_case_					(	self:				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 						snake_case_					(	self:				Optional[int]			):






            '''simple docstring'''




            return







       @unittest.skip(reason='ResNet does not use inputs_embeds'			)
       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            pass







       @unittest.skip(reason='ResNet does not support input and output embeddings'			)
       def 						snake_case_					(	self:				Union[str, Any]			):






            '''simple docstring'''




            pass







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




            __UpperCamelCase,  __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs_for_common()

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

                 __UpperCamelCase				=	['pixel_values']
                 self.assertListEqual(arg_names[:1],A_			)







       def 						snake_case_					(	self:				List[Any]			):






            '''simple docstring'''




            __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*A_			)







       def 						snake_case_					(	self:				Dict			):






            '''simple docstring'''




            __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_backbone(*A_			)







       def 						snake_case_					(	self:				List[Any]			):






            '''simple docstring'''




            __UpperCamelCase,  __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs_for_common()

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






            '''simple docstring'''




            def check_hidden_states_output(A_:				Tuple,A_:				Tuple,A_:				Optional[int]			):
                 __UpperCamelCase				=	model_class(A_			)
                 model.to(A_			)
                 model.eval()

                 with torch.no_grad():
                      __UpperCamelCase				=	model(**self._prepare_for_class(A_,A_			)			)

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

                 __UpperCamelCase				=	self.model_tester.num_stages
                 self.assertEqual(len(A_			),expected_num_stages + 1			)

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

            __UpperCamelCase,  __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs_for_common()
            __UpperCamelCase				=	['basic', 'bottleneck']
            for model_class in self.all_model_classes:
                 for layer_type in layers_type:
                      __UpperCamelCase				=	layer_type
                      __UpperCamelCase				=	True
                      check_hidden_states_output(A_,A_,A_			)

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

                      check_hidden_states_output(A_,A_,A_			)







       @unittest.skip(reason='ResNet does not use feedforward chunking'			)
       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            pass







       def 						snake_case_					(	self:				Any			):






            '''simple docstring'''




            __UpperCamelCase				=	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*A_			)







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






            '''simple docstring'''




            for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __UpperCamelCase				=	ResNetModel.from_pretrained(A_			)
                 self.assertIsNotNone(A_			)






def 						_A						(						)			->				int:


     """simple docstring"""


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



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







       @cached_property
       def 						snake_case_					(	self:				Optional[Any]			):






            '''simple docstring'''




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







       @slow
       def 						snake_case_					(	self:				Optional[int]			):






            '''simple docstring'''




            __UpperCamelCase				=	ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(A_			)

            __UpperCamelCase				=	self.default_image_processor
            __UpperCamelCase				=	prepare_img()
            __UpperCamelCase				=	image_processor(images=A_,return_tensors='pt'			).to(A_			)

            # forward pass
            with torch.no_grad():
                 __UpperCamelCase				=	model(**A_			)

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

            __UpperCamelCase				=	torch.tensor([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]			).to(A_			)

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



@require_torch
class 					__lowerCamelCase	(_a							,     unittest.TestCase		):
       _lowercase    							=      (ResNetBackbone,) if is_torch_available() else ()
       _lowercase    							=      False
       _lowercase    							=      ResNetConfig







       def 						snake_case_					(	self:				Union[str, Any]			):






            '''simple docstring'''




            __UpperCamelCase				=	ResNetModelTester(self			)


