
"""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 					lowerCamelCase		:





     def __init__(self				:   str    ,   _A				:   List[Any]    ,   _A				:   Optional[Any]=None    ,   _A				:   int=None    ,   _A				:   List[Any]=None    ,   _A				:   str="resnet50"    ,   _A				:   str=3    ,   _A				:   str=3_2    ,   _A				:   Tuple=3    ,   _A				:   Dict=True    ,   _A				:   List[str]=True    ,   )						->						List[Any]:
         snake_case								= parent
         snake_case								= out_indices if out_indices is not None else [4]
         snake_case								= stage_names
         snake_case								= out_features
         snake_case								= backbone
         snake_case								= batch_size
         snake_case								= image_size
         snake_case								= num_channels
         snake_case								= use_pretrained_backbone
         snake_case								= is_training





     def 		UpperCAmelCase(self				:   Optional[int]       )						->						List[Any]:
         snake_case								= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
         snake_case								= self.get_config()

         return config, pixel_values





     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Optional[Any]:
         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    ,   _A				:   Union[str, Any]    ,   _A				:   Union[str, Any]       )						->						Optional[int]:
         snake_case								= TimmBackbone(config=_A       )
         model.to(_A       )
         model.eval()
         with torch.no_grad():
             snake_case								= model(_A       )
         self.parent.assertEqual(
             result.feature_map[-1].shape    ,   (self.batch_size, model.channels[-1], 1_4, 1_4)    ,   )





     def 		UpperCAmelCase(self				:   List[str]       )						->						List[Any]:
         snake_case								= self.prepare_config_and_inputs()
         snake_case					,							snake_case								= config_and_inputs
         snake_case								= {"pixel_values": pixel_values}
         return config, inputs_dict







@require_torch
@require_timm
class 					lowerCamelCase		(  A_							,			A_							,			A_							,			unittest.TestCase  ):
     UpperCAmelCase__    :							str									=		(TimmBackbone,) if is_torch_available() else ()
     UpperCAmelCase__    :							str									=		{"feature-extraction": TimmBackbone} if is_torch_available() else {}
     UpperCAmelCase__    :							Tuple									=		False
     UpperCAmelCase__    :							str									=		False
     UpperCAmelCase__    :							Optional[int]									=		False
     UpperCAmelCase__    :							List[Any]									=		False





     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Union[str, Any]:
         snake_case								= TimmBackboneModelTester(self       )
         snake_case								= ConfigTester(self    ,   config_class=_A    ,   has_text_modality=_A       )





     def 		UpperCAmelCase(self				:   List[Any]       )						->						int:
         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				:   Optional[Any]       )						->						Optional[int]:
         snake_case								= "resnet18"
         snake_case								= "microsoft/resnet-18"

         snake_case								= AutoBackbone.from_pretrained(_A    ,   use_timm_backbone=_A       )
         snake_case								= 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]       )

         snake_case								= AutoBackbone.from_pretrained(_A    ,   use_timm_backbone=_A    ,   out_indices=[1, 2, 3]       )
         snake_case								= 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 		UpperCAmelCase(self				:   Any       )						->						Tuple:
         pass





     @unittest.skip("TimmBackbone doesn't have num_hidden_layers attribute"       )
     def 		UpperCAmelCase(self				:   int       )						->						Optional[int]:
         pass





     @unittest.skip("TimmBackbone initialization is managed on the timm side"       )
     def 		UpperCAmelCase(self				:   int       )						->						int:
         pass





     @unittest.skip("TimmBackbone models doesn't have inputs_embeds"       )
     def 		UpperCAmelCase(self				:   int       )						->						Union[str, Any]:
         pass





     @unittest.skip("TimmBackbone models doesn't have inputs_embeds"       )
     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Tuple:
         pass





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





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





     @unittest.skip("model weights aren't tied in TimmBackbone."       )
     def 		UpperCAmelCase(self				:   Optional[int]       )						->						Optional[int]:
         pass





     @unittest.skip("model weights aren't tied in TimmBackbone."       )
     def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						Optional[int]:
         pass





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





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





     @unittest.skip("TimmBackbone doesn't have hidden size info in its configuration."       )
     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						List[str]:
         pass





     @unittest.skip("TimmBackbone doesn't support output_attentions."       )
     def 		UpperCAmelCase(self				:   Optional[int]       )						->						Dict:
         pass





     @unittest.skip("Safetensors is not supported by timm."       )
     def 		UpperCAmelCase(self				:   Tuple       )						->						Dict:
         pass





     @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
     def 		UpperCAmelCase(self				:   int       )						->						str:
         pass





     def 		UpperCAmelCase(self				:   Tuple       )						->						Optional[Any]:
         snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

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

             snake_case								= ["pixel_values"]
             self.assertListEqual(arg_names[:1]    ,   _A       )





     def 		UpperCAmelCase(self				:   str       )						->						int:
         snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()
         snake_case								= True
         snake_case								= self.has_attentions

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

         snake_case								= self._prepare_for_class(_A    ,   _A       )
         snake_case								= model(**_A       )
         snake_case								= outputs[0][-1]

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

         if self.has_attentions:
             snake_case								= 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 		UpperCAmelCase(self				:   List[str]       )						->						Any:
         snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             snake_case								= model_class(_A       )
             model.to(_A       )
             model.eval()
             snake_case								= 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
             snake_case								= copy.deepcopy(_A       )
             snake_case								= None
             snake_case								= model_class(_A       )
             model.to(_A       )
             model.eval()
             snake_case								= model(**_A       )

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

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



from ....utils import logging


_A   =			logging.get_logger(__name__)







class 					lowerCamelCase		(  A_  ):





     def __init__(self				:   Tuple    ,   _A				:   Optional[int]    ,   _A				:   Tuple=None    ,   _A				:   Union[str, Any]=2_0_4_8       )						->						List[Any]:
         snake_case								= config.__dict__
         snake_case								= modal_hidden_size
         if num_labels:
             snake_case								= num_labels

