


import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class 				lowerCamelCase__       :
     SCREAMING_SNAKE_CASE__				      =      ()
     SCREAMING_SNAKE_CASE__				      =      True





     def 					__A (self	)					->       List[str]:
      _lowercase											=self.config_class

      # test default config
      _lowercase											=config_class()
      self.assertIsNotNone(UpperCAmelCase	)
      _lowercase											=['''stem'''] + [f"stage{idx}" for idx in range(1		,					len(config.depths	) + 1	)]
      self.assertEqual(config.stage_names		,					UpperCAmelCase	)
      self.assertTrue(set(config.out_features	).issubset(set(config.stage_names	)	)	)

      # Test out_features and out_indices are correctly set
      # out_features and out_indices both None
      _lowercase											=config_class(out_features=UpperCAmelCase		,					out_indices=UpperCAmelCase	)
      self.assertEqual(config.out_features		,					[config.stage_names[-1]]	)
      self.assertEqual(config.out_indices		,					[len(config.stage_names	) - 1]	)

      # out_features and out_indices both set
      _lowercase											=config_class(out_features=['''stem''', '''stage1''']		,					out_indices=[0, 1]	)
      self.assertEqual(config.out_features		,					['''stem''', '''stage1''']	)
      self.assertEqual(config.out_indices		,					[0, 1]	)

      # Only out_features set
      _lowercase											=config_class(out_features=['''stage1''', '''stage3''']	)
      self.assertEqual(config.out_features		,					['''stage1''', '''stage3''']	)
      self.assertEqual(config.out_indices		,					[1, 3]	)

      # Only out_indices set
      _lowercase											=config_class(out_indices=[0, 2]	)
      self.assertEqual(config.out_features		,					[config.stage_names[0], config.stage_names[2]]	)
      self.assertEqual(config.out_indices		,					[0, 2]	)

      # Error raised when out_indices do not correspond to out_features
      with self.assertRaises(UpperCAmelCase	):
       _lowercase											=config_class(out_features=['''stage1''', '''stage2''']		,					out_indices=[0, 2]	)





     def 					__A (self	)					->       Optional[int]:
      _lowercase				,   _lowercase											=self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       _lowercase											=model_class(UpperCAmelCase	)
       _lowercase											=inspect.signature(model.forward	)
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       _lowercase											=[*signature.parameters.keys()]
       _lowercase											=['''pixel_values''']
       self.assertListEqual(arg_names[:1]		,					UpperCAmelCase	)





     def 					__A (self	)					->       Tuple:
      _lowercase				,   _lowercase											=self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       _lowercase											=model_class(UpperCAmelCase	)
       self.assertEqual(len(model.channels	)		,					len(config.out_features	)	)
       _lowercase											=model.num_features
       _lowercase											=[config.stage_names.index(UpperCAmelCase	) for feat in config.out_features]
       _lowercase											=[num_features[idx] for idx in out_indices]
       self.assertListEqual(model.channels		,					UpperCAmelCase	)

       _lowercase											=copy.deepcopy(UpperCAmelCase	)
       _lowercase											=None
       _lowercase											=model_class(UpperCAmelCase	)
       self.assertEqual(len(model.channels	)		,					1	)
       self.assertListEqual(model.channels		,					[num_features[-1]]	)

       _lowercase											=copy.deepcopy(UpperCAmelCase	)
       _lowercase											=None
       _lowercase											=model_class(UpperCAmelCase	)
       self.assertEqual(len(model.channels	)		,					1	)
       self.assertListEqual(model.channels		,					[num_features[-1]]	)





     def 					__A (self	)					->       List[Any]:
      _lowercase				,   _lowercase											=self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       _lowercase											=model_class(UpperCAmelCase	)
       model.to(UpperCAmelCase	)
       model.eval()
       _lowercase											=model(**UpperCAmelCase	)

       self.assertEqual(len(result.feature_maps	)		,					len(config.out_features	)	)
       self.assertEqual(len(model.channels	)		,					len(config.out_features	)	)
       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
       _lowercase											=copy.deepcopy(UpperCAmelCase	)
       _lowercase											=None
       _lowercase											=model_class(UpperCAmelCase	)
       model.to(UpperCAmelCase	)
       model.eval()
       _lowercase											=model(**UpperCAmelCase	)

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

       _lowercase											=copy.deepcopy(UpperCAmelCase	)
       _lowercase											=None
       _lowercase											=model_class(UpperCAmelCase	)
       model.to(UpperCAmelCase	)
       model.eval()
       _lowercase											=model(**UpperCAmelCase	)

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

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





     def 					__A (self	)					->       str:
      _lowercase				,   _lowercase											=self.model_tester.prepare_config_and_inputs_for_common()

      for backbone_class in self.all_model_classes:
       _lowercase											=backbone_class(UpperCAmelCase	)

       self.assertTrue(hasattr(UpperCAmelCase		,					'''backbone_type'''	)	)
       self.assertTrue(hasattr(UpperCAmelCase		,					'''stage_names'''	)	)
       self.assertTrue(hasattr(UpperCAmelCase		,					'''num_features'''	)	)
       self.assertTrue(hasattr(UpperCAmelCase		,					'''out_indices'''	)	)
       self.assertTrue(hasattr(UpperCAmelCase		,					'''out_features'''	)	)
       self.assertTrue(hasattr(UpperCAmelCase		,					'''out_feature_channels'''	)	)
       self.assertTrue(hasattr(UpperCAmelCase		,					'''channels'''	)	)

       self.assertIsInstance(backbone.backbone_type		,					UpperCAmelCase	)
       # Verify num_features has been initialized in the backbone init
       self.assertIsNotNone(backbone.num_features	)
       self.assertTrue(len(backbone.channels	) == len(backbone.out_indices	)	)
       self.assertTrue(len(backbone.stage_names	) == len(backbone.num_features	)	)
       self.assertTrue(len(backbone.channels	) <= len(backbone.num_features	)	)
       self.assertTrue(len(backbone.out_feature_channels	) == len(backbone.stage_names	)	)





     def 					__A (self	)					->       Optional[int]:
      _lowercase				,   _lowercase											=self.model_tester.prepare_config_and_inputs_for_common()
      _lowercase											=inputs_dict['''pixel_values'''].shape[0]

      for backbone_class in self.all_model_classes:
       _lowercase											=backbone_class(UpperCAmelCase	)
       backbone.to(UpperCAmelCase	)
       backbone.eval()

       _lowercase											=backbone(**UpperCAmelCase	)

       # Test default outputs and verify feature maps
       self.assertIsInstance(outputs.feature_maps		,					UpperCAmelCase	)
       self.assertTrue(len(outputs.feature_maps	) == len(backbone.channels	)	)
       for feature_map, n_channels in zip(outputs.feature_maps		,					backbone.channels	):
        self.assertTrue(feature_map.shape[:2]		,					(batch_size, n_channels)	)
       self.assertIsNone(outputs.hidden_states	)
       self.assertIsNone(outputs.attentions	)

       # Test output_hidden_states=True
       _lowercase											=backbone(**UpperCAmelCase		,					output_hidden_states=UpperCAmelCase	)
       self.assertIsNotNone(outputs.hidden_states	)
       self.assertTrue(len(outputs.hidden_states	)		,					len(backbone.stage_names	)	)
       for hidden_state, n_channels in zip(outputs.hidden_states		,					backbone.channels	):
        self.assertTrue(hidden_state.shape[:2]		,					(batch_size, n_channels)	)

       # Test output_attentions=True
       if self.has_attentions:
        _lowercase											=backbone(**UpperCAmelCase		,					output_attentions=UpperCAmelCase	)
        self.assertIsNotNone(outputs.attentions	)





from math import sqrt
def     UpperCAmelCase_ (							__snake_case						)					->      list[int]:







 """simple docstring"""


 _lowercase											=[1]
 for i in range(2					,						int(sqrt(__snake_case						)						) + 1					,						1						):
  if number % i == 0:
   values.append(__snake_case						)
   if int(number // i						) != i:
    values.append(int(number // i						)						)
 return sorted(__snake_case						)
def     UpperCAmelCase_ (							__snake_case						)					->      bool:







 """simple docstring"""


 return sum(factors(__snake_case						)						) > n
def     UpperCAmelCase_ (							__snake_case						)					->      bool:







 """simple docstring"""


 _lowercase											=factors(__snake_case						)
 _lowercase											=len(__snake_case						)
 _lowercase											=[[0 for i in range(number + 1						)] for j in range(r + 1						)]
 for i in range(r + 1						):
  _lowercase											=True

 for i in range(1					,						number + 1						):
  _lowercase											=False

 for i in range(1					,						r + 1						):
  for j in range(1					,						number + 1						):
   if j < values[i - 1]:
    _lowercase											=subset[i - 1][j]
   else:
    _lowercase											=subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

 return subset[r][number] != 0
def     UpperCAmelCase_ (							__snake_case						)					->      bool:







 """simple docstring"""


 return abundant(__snake_case						) and not semi_perfect(__snake_case						)


if __name__ == "__main__":
  import doctest

  doctest.testmod(verbose=True)
  for number in (69, 70, 71):
    print(f'''{number} is {'' if weird(number) else 'not '}weird.''')

