
'''simple docstring'''




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





     def __init__(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE="resnet50"						,			SCREAMING_SNAKE_CASE=3						,			SCREAMING_SNAKE_CASE=32						,			SCREAMING_SNAKE_CASE=3						,			SCREAMING_SNAKE_CASE=True						,			SCREAMING_SNAKE_CASE=True						,			) ->				List[str]:






         """simple docstring"""






         A       :   Tuple					=						parent
         A       :   Any					=						out_indices if out_indices is not None else [4]
         A       :   Union[str, Any]					=						stage_names
         A       :   Any					=						out_features
         A       :   Union[str, Any]					=						backbone
         A       :   Dict					=						batch_size
         A       :   Union[str, Any]					=						image_size
         A       :   Union[str, Any]					=						num_channels
         A       :   List[str]					=						use_pretrained_backbone
         A       :   Tuple					=						is_training





     def 				__lowerCAmelCase							(							self	) ->				Dict:






         """simple docstring"""






         A       :   Optional[Any]					=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)
         A       :   Union[str, Any]					=						self.get_config()

         return config, pixel_values





     def 				__lowerCAmelCase							(							self	) ->				str:






         """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 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	) ->				str:






         """simple docstring"""






         A       :   List[Any]					=						TimmBackbone(config=snake_case_	)
         model.to(snake_case_	)
         model.eval()
         with torch.no_grad():
             A       :   List[str]					=						model(snake_case_	)
         self.parent.assertEqual(
             result.feature_map[-1].shape						,			(self.batch_size, model.channels[-1], 14, 14)						,			)





     def 				__lowerCAmelCase							(							self	) ->				List[str]:






         """simple docstring"""






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





@require_torch
@require_timm
class  A				(							UpperCAmelCase__    ,			UpperCAmelCase__    ,			UpperCAmelCase__    ,			unittest.TestCase						):
     __magic_name__						=		(TimmBackbone,) if is_torch_available() else ()
     __magic_name__						=		{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
     __magic_name__						=		False
     __magic_name__						=		False
     __magic_name__						=		False
     __magic_name__						=		False





     def 				__lowerCAmelCase							(							self	) ->				Dict:






         """simple docstring"""






         A       :   Tuple					=						TimmBackboneModelTester(self	)
         A       :   List[Any]					=						ConfigTester(self						,			config_class=snake_case_						,			has_text_modality=snake_case_	)





     def 				__lowerCAmelCase							(							self	) ->				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 				__lowerCAmelCase							(							self	) ->				List[Any]:






         """simple docstring"""






         A       :   List[Any]					=						'resnet18'
         A       :   Optional[int]					=						'microsoft/resnet-18'

         A       :   str					=						AutoBackbone.from_pretrained(snake_case_						,			use_timm_backbone=snake_case_	)
         A       :   Dict					=						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]	)

         A       :   str					=						AutoBackbone.from_pretrained(snake_case_						,			use_timm_backbone=snake_case_						,			out_indices=[1, 2, 3]	)
         A       :   List[Any]					=						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 				__lowerCAmelCase							(							self	) ->				Optional[Any]:






         """simple docstring"""






         pass





     @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''	)
     def 				__lowerCAmelCase							(							self	) ->				List[Any]:






         """simple docstring"""






         pass





     @unittest.skip('''TimmBackbone initialization is managed on the timm side'''	)
     def 				__lowerCAmelCase							(							self	) ->				str:






         """simple docstring"""






         pass





     @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''	)
     def 				__lowerCAmelCase							(							self	) ->				List[Any]:






         """simple docstring"""






         pass





     @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''	)
     def 				__lowerCAmelCase							(							self	) ->				List[Any]:






         """simple docstring"""






         pass





     @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''	)
     def 				__lowerCAmelCase							(							self	) ->				Optional[int]:






         """simple docstring"""






         pass





     @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''	)
     def 				__lowerCAmelCase							(							self	) ->				Optional[Any]:






         """simple docstring"""






         pass





     @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''	)
     def 				__lowerCAmelCase							(							self	) ->				Any:






         """simple docstring"""






         pass





     @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''	)
     def 				__lowerCAmelCase							(							self	) ->				Optional[Any]:






         """simple docstring"""






         pass





     @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''	)
     def 				__lowerCAmelCase							(							self	) ->				Tuple:






         """simple docstring"""






         pass





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






         """simple docstring"""






         pass





     @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''	)
     def 				__lowerCAmelCase							(							self	) ->				Any:






         """simple docstring"""






         pass





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






         """simple docstring"""






         pass





     @unittest.skip('''Safetensors is not supported by timm.'''	)
     def 				__lowerCAmelCase							(							self	) ->				List[Any]:






         """simple docstring"""






         pass





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






         """simple docstring"""






         pass





     def 				__lowerCAmelCase							(							self	) ->				Optional[int]:






         """simple docstring"""






         A       :   Optional[int]					=						self.model_tester.prepare_config_and_inputs_for_common()

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

             A       :   Tuple					=						['pixel_values']
             self.assertListEqual(arg_names[:1]						,			snake_case_	)





     def 				__lowerCAmelCase							(							self	) ->				List[Any]:






         """simple docstring"""






         A       :   List[Any]					=						self.model_tester.prepare_config_and_inputs_for_common()
         A       :   Union[str, Any]					=						True
         A       :   Any					=						self.has_attentions

         # no need to test all models as different heads yield the same functionality
         A       :   Dict					=						self.all_model_classes[0]
         A       :   Tuple					=						model_class(snake_case_	)
         model.to(snake_case_	)

         A       :   List[Any]					=						self._prepare_for_class(snake_case_						,			snake_case_	)
         A       :   List[Any]					=						model(**snake_case_	)
         A       :   Union[str, Any]					=						outputs[0][-1]

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

         if self.has_attentions:
             A       :   Tuple					=						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 				__lowerCAmelCase							(							self	) ->				int:






         """simple docstring"""






         A       :   int					=						self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             A       :   Optional[int]					=						model_class(snake_case_	)
             model.to(snake_case_	)
             model.eval()
             A       :   Tuple					=						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
             A       :   Dict					=						copy.deepcopy(snake_case_	)
             A       :   List[Any]					=						None
             A       :   Union[str, Any]					=						model_class(snake_case_	)
             model.to(snake_case_	)
             model.eval()
             A       :   Tuple					=						model(**snake_case_	)

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

             # Check backbone can be initialized with fresh weights
             A       :   Optional[int]					=						copy.deepcopy(snake_case_	)
             A       :   List[Any]					=						False
             A       :   int					=						model_class(snake_case_	)
             model.to(snake_case_	)
             model.eval()
             A       :   Tuple					=						model(**snake_case_	)











"""simple docstring"""




def 						UpperCAmelCase__		(     _UpperCAmelCase					):






  """simple docstring"""





  A_  :       List[str]										=  hex_num.strip()
  if not hex_num:
    raise ValueError('No value was passed to the function'					)

  A_  :       Any										=  hex_num[0] == '-'
  if is_negative:
    A_  :       Optional[Any]										=  hex_num[1:]

  try:
    A_  :       Tuple										=  int(_UpperCAmelCase ,					16					)
  except ValueError:
    raise ValueError('Invalid value was passed to the function'					)

  A_  :       Union[str, Any]										=  ''
  while int_num > 0:
    A_  :       Optional[Any]										=  str(int_num % 2					) + bin_str
    int_num >>= 1

  return int(('-' + bin_str) if is_negative else bin_str					)


if __name__ == "__main__":
   import doctest

   doctest.testmod()