
"""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 			__magic_name__       :
       def __init__(     self ,				A_ ,				A_=None ,				A_=None ,				A_=None ,				A_="resnet50" ,				A_=3 ,				A_=32 ,				A_=3 ,				A_=True ,				A_=True ,				)     ->	Any:





         """simple docstring"""




         _lowercase:			Optional[int]       =     parent
         _lowercase:			List[str]       =     out_indices if out_indices is not None else [4]
         _lowercase:			Union[str, Any]       =     stage_names
         _lowercase:			Tuple       =     out_features
         _lowercase:			Tuple       =     backbone
         _lowercase:			List[str]       =     batch_size
         _lowercase:			Optional[Any]       =     image_size
         _lowercase:			Any       =     num_channels
         _lowercase:			Optional[Any]       =     use_pretrained_backbone
         _lowercase:			Optional[int]       =     is_training
       def 							lowercase_							(     self       )     ->	Optional[Any]:





         """simple docstring"""




         _lowercase:			List[Any]       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
         _lowercase:			Dict       =     self.get_config()

         return config, pixel_values
       def 							lowercase_							(     self       )     ->	Union[str, 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 							lowercase_							(     self ,				A_ ,				A_       )     ->	Dict:





         """simple docstring"""




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



       def 							lowercase_							(     self       )     ->	Union[str, Any]:





         """simple docstring"""




         _lowercase:			str       =     self.prepare_config_and_inputs()
         _lowercase ,				_lowercase:			List[str]       =     config_and_inputs
         _lowercase:			Optional[int]       =     {'''pixel_values''': pixel_values}
         return config, inputs_dict


@require_torch
@require_timm
class 			__magic_name__       (       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 							lowercase_							(     self       )     ->	List[str]:





         """simple docstring"""




         _lowercase:			Union[str, Any]       =     TimmBackboneModelTester(self       )
         _lowercase:			int       =     ConfigTester(self ,				config_class=A_ ,				has_text_modality=A_       )
       def 							lowercase_							(     self       )     ->	int:





         """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 							lowercase_							(     self       )     ->	Dict:





         """simple docstring"""




         _lowercase:			List[Any]       =     '''resnet18'''
         _lowercase:			Tuple       =     '''microsoft/resnet-18'''

         _lowercase:			Union[str, Any]       =     AutoBackbone.from_pretrained(A_ ,				use_timm_backbone=A_       )
         _lowercase:			List[str]       =     AutoBackbone.from_pretrained(A_       )

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

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





         """simple docstring"""




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





         """simple docstring"""




         pass
       @unittest.skip('''TimmBackbone initialization is managed on the timm side'''       )
       def 							lowercase_							(     self       )     ->	Optional[Any]:





         """simple docstring"""




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





         """simple docstring"""




         pass
       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''       )
       def 							lowercase_							(     self       )     ->	Dict:





         """simple docstring"""




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





         """simple docstring"""




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





         """simple docstring"""




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





         """simple docstring"""




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





         """simple docstring"""




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





         """simple docstring"""




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





         """simple docstring"""




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





         """simple docstring"""




         pass
       @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''       )
       def 							lowercase_							(     self       )     ->	int:





         """simple docstring"""




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





         """simple docstring"""




         pass
       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''       )
       def 							lowercase_							(     self       )     ->	Optional[int]:





         """simple docstring"""




         pass
       def 							lowercase_							(     self       )     ->	Union[str, Any]:





         """simple docstring"""




         _lowercase ,				_lowercase:			str       =     self.model_tester.prepare_config_and_inputs_for_common()

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

           _lowercase:			Any       =     ['''pixel_values''']
           self.assertListEqual(arg_names[:1] ,				A_       )
       def 							lowercase_							(     self       )     ->	Tuple:





         """simple docstring"""




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

         # no need to test all models as different heads yield the same functionality
         _lowercase:			Any       =     self.all_model_classes[0]
         _lowercase:			Union[str, Any]       =     model_class(A_       )
         model.to(A_       )

         _lowercase:			str       =     self._prepare_for_class(A_ ,				A_       )
         _lowercase:			Optional[Any]       =     model(**A_       )
         _lowercase:			List[str]       =     outputs[0][-1]

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

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

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

         self.assertIsNotNone(hidden_states.grad       )

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



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





         """simple docstring"""




         _lowercase ,				_lowercase:			Dict       =     self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           _lowercase:			str       =     model_class(A_       )
           model.to(A_       )
           model.eval()
           _lowercase:			Dict       =     model(**A_       )

           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:			List[Any]       =     copy.deepcopy(A_       )
           _lowercase:			Any       =     None
           _lowercase:			Dict       =     model_class(A_       )
           model.to(A_       )
           model.eval()
           _lowercase:			Union[str, Any]       =     model(**A_       )

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

           # Check backbone can be initialized with fresh weights
           _lowercase:			str       =     copy.deepcopy(A_       )
           _lowercase:			Union[str, Any]       =     False
           _lowercase:			List[str]       =     model_class(A_       )
           model.to(A_       )
           model.eval()
           _lowercase:			str       =     model(**A_       )


"""simple docstring"""




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  return number | (1 << position)




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  return number & ~(1 << position)




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  return number ^ (1 << position)




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  return ((number >> position) & 1) == 1




def  _lowerCAmelCase		(		_UpperCamelCase ,				_UpperCamelCase						):






  """simple docstring"""



  return int((number & (1 << position)) != 0						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
