

import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
      import torch

      from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin




class   UpperCamelCase			:

    def __init__(      self			:   Optional[int]				,     snake_case__			:   int				,     snake_case__			:   Tuple=None				,     snake_case__			:   Optional[int]=None				,     snake_case__			:   Dict=None				,     snake_case__			:   List[Any]="resnet50"				,     snake_case__			:   List[str]=3				,     snake_case__			:   Optional[Any]=3_2				,     snake_case__			:   str=3				,     snake_case__			:   int=True				,     snake_case__			:   Any=True				,     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      parent
     SCREAMING_SNAKE_CASE		    =      out_indices if out_indices is not None else [4]
     SCREAMING_SNAKE_CASE		    =      stage_names
     SCREAMING_SNAKE_CASE		    =      out_features
     SCREAMING_SNAKE_CASE		    =      backbone
     SCREAMING_SNAKE_CASE		    =      batch_size
     SCREAMING_SNAKE_CASE		    =      image_size
     SCREAMING_SNAKE_CASE		    =      num_channels
     SCREAMING_SNAKE_CASE		    =      use_pretrained_backbone
     SCREAMING_SNAKE_CASE		    =      is_training

    def UpperCamelCase      (      self			:   Tuple     ):

     """simple docstring"""






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

     return config, pixel_values

    def UpperCamelCase      (      self			:   List[Any]     ):

     """simple docstring"""






     return TimmBackboneConfig(
         image_size=self.image_size				,     num_channels=self.num_channels				,     out_features=self.out_features				,     out_indices=self.out_indices				,     stage_names=self.stage_names				,     use_pretrained_backbone=self.use_pretrained_backbone				,     backbone=self.backbone				,     )

    def UpperCamelCase      (      self			:   Tuple				,     snake_case__			:   Dict				,     snake_case__			:   Dict     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      TimmBackbone(config=snake_case__     )
     model.to(snake_case__     )
     model.eval()
     with torch.no_grad():
      SCREAMING_SNAKE_CASE		    =      model(snake_case__     )
     self.parent.assertEqual(
         result.feature_map[-1].shape				,     (self.batch_size, model.channels[-1], 1_4, 1_4)				,     )




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

     """simple docstring"""






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




@require_torch
@require_timm
class   UpperCamelCase			(  SCREAMING_SNAKE_CASE						,      SCREAMING_SNAKE_CASE						,      SCREAMING_SNAKE_CASE						,      unittest.TestCase ):
    __UpperCamelCase    =(TimmBackbone,) if is_torch_available() else ()
    __UpperCamelCase    ={"feature-extraction": TimmBackbone} if is_torch_available() else {}
    __UpperCamelCase    =False
    __UpperCamelCase    =False
    __UpperCamelCase    =False
    __UpperCamelCase    =False

    def UpperCamelCase      (      self			:   Dict     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      TimmBackboneModelTester(self     )
     SCREAMING_SNAKE_CASE		    =      ConfigTester(self				,     config_class=snake_case__				,     has_text_modality=snake_case__     )

    def UpperCamelCase      (      self			:   List[str]     ):

     """simple docstring"""






     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 UpperCamelCase      (      self			:   Any     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      'resnet18'
     SCREAMING_SNAKE_CASE		    =      'microsoft/resnet-18'

     SCREAMING_SNAKE_CASE		    =      AutoBackbone.from_pretrained(snake_case__				,     use_timm_backbone=snake_case__     )
     SCREAMING_SNAKE_CASE		    =      AutoBackbone.from_pretrained(snake_case__     )

     self.assertEqual(len(timm_model.out_features     )				,     len(transformers_model.out_features     )     )
     self.assertEqual(len(timm_model.stage_names     )				,     len(transformers_model.stage_names     )     )
     self.assertEqual(timm_model.channels				,     transformers_model.channels     )
     # Out indices are set to the last layer by default. For timm models, we don't know
     # the number of layers in advance, so we set it to (-1,), whereas for transformers
     # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
     self.assertEqual(timm_model.out_indices				,     (-1,)     )
     self.assertEqual(transformers_model.out_indices				,     [len(timm_model.stage_names     ) - 1]     )

     SCREAMING_SNAKE_CASE		    =      AutoBackbone.from_pretrained(snake_case__				,     use_timm_backbone=snake_case__				,     out_indices=[1, 2, 3]     )
     SCREAMING_SNAKE_CASE		    =      AutoBackbone.from_pretrained(snake_case__				,     out_indices=[1, 2, 3]     )

     self.assertEqual(timm_model.out_indices				,     transformers_model.out_indices     )
     self.assertEqual(len(timm_model.out_features     )				,     len(transformers_model.out_features     )     )
     self.assertEqual(timm_model.channels				,     transformers_model.channels     )

    @unittest.skip('TimmBackbone doesn\'t support feed forward chunking'     )
    def UpperCamelCase      (      self			:   str     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'     )
    def UpperCamelCase      (      self			:   int     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone initialization is managed on the timm side'     )
    def UpperCamelCase      (      self			:   List[Any]     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'     )
    def UpperCamelCase      (      self			:   Any     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'     )
    def UpperCamelCase      (      self			:   Dict     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'     )
    def UpperCamelCase      (      self			:   Tuple     ):

     """simple docstring"""






     pass

    @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'     )
    def UpperCamelCase      (      self			:   Dict     ):

     """simple docstring"""






     pass

    @unittest.skip('model weights aren\'t tied in TimmBackbone.'     )
    def UpperCamelCase      (      self			:   str     ):

     """simple docstring"""






     pass

    @unittest.skip('model weights aren\'t tied in TimmBackbone.'     )
    def UpperCamelCase      (      self			:   Union[str, Any]     ):

     """simple docstring"""






     pass

    @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'     )
    def UpperCamelCase      (      self			:   Dict     ):

     """simple docstring"""






     pass

    @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'     )
    def UpperCamelCase      (      self			:   List[str]     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'     )
    def UpperCamelCase      (      self			:   Union[str, Any]     ):

     """simple docstring"""






     pass

    @unittest.skip('TimmBackbone doesn\'t support output_attentions.'     )
    def UpperCamelCase      (      self			:   Tuple     ):

     """simple docstring"""






     pass

    @unittest.skip('Safetensors is not supported by timm.'     )
    def UpperCamelCase      (      self			:   Optional[int]     ):

     """simple docstring"""






     pass

    @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'     )
    def UpperCamelCase      (      self			:   int     ):

     """simple docstring"""






     pass

    def UpperCamelCase      (      self			:   Optional[int]     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE		    =      self.model_tester.prepare_config_and_inputs_for_common()

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

      SCREAMING_SNAKE_CASE		    =      ['pixel_values']
      self.assertListEqual(arg_names[:1]				,     snake_case__     )

    def UpperCamelCase      (      self			:   Optional[int]     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE		    =      self.model_tester.prepare_config_and_inputs_for_common()
     SCREAMING_SNAKE_CASE		    =      True
     SCREAMING_SNAKE_CASE		    =      self.has_attentions

     # no need to test all models as different heads yield the same functionality
     SCREAMING_SNAKE_CASE		    =      self.all_model_classes[0]
     SCREAMING_SNAKE_CASE		    =      model_class(snake_case__     )
     model.to(snake_case__     )

     SCREAMING_SNAKE_CASE		    =      self._prepare_for_class(snake_case__				,     snake_case__     )
     SCREAMING_SNAKE_CASE		    =      model(**snake_case__     )
     SCREAMING_SNAKE_CASE		    =      outputs[0][-1]

     # Encoder-/Decoder-only models
     SCREAMING_SNAKE_CASE		    =      outputs.hidden_states[0]
     hidden_states.retain_grad()

     if self.has_attentions:
      SCREAMING_SNAKE_CASE		    =      outputs.attentions[0]
      attentions.retain_grad()

     output.flatten()[0].backward(retain_graph=snake_case__     )

     self.assertIsNotNone(hidden_states.grad     )

     if self.has_attentions:
      self.assertIsNotNone(attentions.grad     )




    def UpperCamelCase      (      self			:   Any     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE		    =      self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
      SCREAMING_SNAKE_CASE		    =      model_class(snake_case__     )
      model.to(snake_case__     )
      model.eval()
      SCREAMING_SNAKE_CASE		    =      model(**snake_case__     )

      self.assertEqual(len(result.feature_maps     )				,     len(config.out_indices     )     )
      self.assertEqual(len(model.channels     )				,     len(config.out_indices     )     )

      # Check output of last stage is taken if out_features=None, out_indices=None
      SCREAMING_SNAKE_CASE		    =      copy.deepcopy(snake_case__     )
      SCREAMING_SNAKE_CASE		    =      None
      SCREAMING_SNAKE_CASE		    =      model_class(snake_case__     )
      model.to(snake_case__     )
      model.eval()
      SCREAMING_SNAKE_CASE		    =      model(**snake_case__     )

      self.assertEqual(len(result.feature_maps     )				,     1     )
      self.assertEqual(len(model.channels     )				,     1     )

      # Check backbone can be initialized with fresh weights
      SCREAMING_SNAKE_CASE		    =      copy.deepcopy(snake_case__     )
      SCREAMING_SNAKE_CASE		    =      False
      SCREAMING_SNAKE_CASE		    =      model_class(snake_case__     )
      model.to(snake_case__     )
      model.eval()
      SCREAMING_SNAKE_CASE		    =      model(**snake_case__     )




def 							__lowerCAmelCase     (							_UpperCamelCase		:	List[str]=2_81_23						)		->				str:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE		    =      [1] * (limit + 1)

 for i in range(2		,				int(limit**0.5						) + 1						):
  sum_divs[i * i] += i
  for k in range(i + 1		,				limit // i + 1						):
   sum_divs[k * i] += k + i

 SCREAMING_SNAKE_CASE		    =      set()
 SCREAMING_SNAKE_CASE		    =      0

 for n in range(1		,				limit + 1						):
  if sum_divs[n] > n:
   abundants.add(_UpperCamelCase						)

  if not any((n - a in abundants) for a in abundants						):
   res += n

 return res


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

