



"""simple docstring"""





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       ,	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=["stage2", "stage3", "stage4"]       ,	lowerCamelCase=[2, 3, 4]       ,	):




      '''simple docstring'''




      _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				)
      _lowerCAmelCase					     =		out_features
      _lowerCAmelCase					     =		out_indices







   def 							A__						(self				):




      '''simple docstring'''




      _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 							A__						(self				):




      '''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 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetModel(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 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




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







   def 							A__						(self       ,	lowerCamelCase       ,	lowerCamelCase       ,	lowerCamelCase				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetBackbone(config=lowerCamelCase				)
      model.to(lowerCamelCase				)
      model.eval()
      _lowerCAmelCase					     =		model(lowerCamelCase				)

      # 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
      _lowerCAmelCase					     =		None
      _lowerCAmelCase					     =		ResNetBackbone(config=lowerCamelCase				)
      model.to(lowerCamelCase				)
      model.eval()
      _lowerCAmelCase					     =		model(lowerCamelCase				)

      # 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 							A__						(self				):




      '''simple docstring'''




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





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

   __UpperCamelCase									=   True
   __UpperCamelCase									=   False
   __UpperCamelCase									=   False
   __UpperCamelCase									=   False
   __UpperCamelCase									=   False







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetModelTester(self				)
      _lowerCAmelCase					     =		ConfigTester(self       ,	config_class=lowerCamelCase       ,	has_text_modality=lowerCamelCase				)







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




      '''simple docstring'''




      return







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




      '''simple docstring'''




      pass







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




      '''simple docstring'''




      pass







   def 							A__						(self				):




      '''simple docstring'''




      _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 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*lowerCamelCase				)







   def 							A__						(self				):




      '''simple docstring'''




      _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 							A__						(self				):




      '''simple docstring'''




      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				)

         # 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]       ,	)

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







   @unittest.skip(reason="""ResNet does not use feedforward chunking"""				)
   def 							A__						(self				):




      '''simple docstring'''




      pass







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase				)







   @slow
   def 							A__						(self				):




      '''simple docstring'''




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






def 	__UpperCAmelCase					(       )							->	Optional[int]:






   """simple docstring"""


   _lowerCAmelCase					     =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
   return image


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







   @cached_property
   def 							A__						(self				):




      '''simple docstring'''




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







   @slow
   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetForImageClassification.from_pretrained(RESNET_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, 1_000)				)
      self.assertEqual(outputs.logits.shape       ,	lowerCamelCase				)

      _lowerCAmelCase					     =		torch.tensor([-11.1069, -9.7877, -8.3777]				).to(lowerCamelCase				)

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





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







   def 							A__						(self				):




      '''simple docstring'''




      _lowerCAmelCase					     =		ResNetModelTester(self				)




"""simple docstring"""





from itertools import combinations_with_replacement






def 	__UpperCAmelCase					(       snake_case_  :  int = 100   )							->	int:






   """simple docstring"""


   _lowerCAmelCase					     =		[*list(range(1   ,	21   )   ), 25]
   _lowerCAmelCase					     =		[2 * x for x in range(1   ,	21   )] + [50]
   _lowerCAmelCase					     =		[3 * x for x in range(1   ,	21   )]
   _lowerCAmelCase					     =		singles + doubles + triples + [0]

   _lowerCAmelCase					     =		0
   _lowerCAmelCase					     =		42
   _lowerCAmelCase					     =		42
   _lowerCAmelCase					     =		42
   _lowerCAmelCase					     =		42

   for double in doubles:
      for throwa, throwa in combinations_with_replacement(snake_case_   ,	2   ):
         _lowerCAmelCase					     =		double + throwa + throwa
         if checkout_total < limit:
            num_checkouts += 1

   return num_checkouts


if __name__ == "__main__":
  print(F'{solution() = }')