


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		:	Optional[Any]     ,  lowercase_		:	Optional[int]     ,  lowercase_		:	List[str]=None     ,  lowercase_		:	List[str]=None     ,  lowercase_		:	str=None     ,  lowercase_		:	Tuple="resnet50"     ,  lowercase_		:	Tuple=3     ,  lowercase_		:	Union[str, Any]=32     ,  lowercase_		:	Optional[int]=3     ,  lowercase_		:	Dict=True     ,  lowercase_		:	Union[str, Any]=True     ,  )   ->		Tuple:
             """simple docstring"""




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






      def 			lowerCamelCase			(   self		:	List[str]					)   ->		Dict:
             """simple docstring"""




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

             return config, pixel_values






      def 			lowerCamelCase			(   self		:	Any					)   ->		Tuple:
             """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		:	Optional[Any]     ,  lowercase_		:	Optional[Any]     ,  lowercase_		:	Tuple					)   ->		str:
             """simple docstring"""




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






      def 			lowerCamelCase			(   self		:	int					)   ->		str:
             """simple docstring"""




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




@require_torch
@require_timm
class A    (  UpperCamelCase_       ,				UpperCamelCase_       ,				UpperCamelCase_       ,				unittest.TestCase	):
      UpperCamelCase__				:    Any =(TimmBackbone,) if is_torch_available() else ()
      UpperCamelCase__				:    str ={'feature-extraction': TimmBackbone} if is_torch_available() else {}
      UpperCamelCase__				:    List[str] =False
      UpperCamelCase__				:    str =False
      UpperCamelCase__				:    Optional[Any] =False
      UpperCamelCase__				:    Optional[Any] =False






      def 			lowerCamelCase			(   self		:	List[str]					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Dict            =TimmBackboneModelTester(self					)
             _lowerCamelCase			:						List[Any]            =ConfigTester(self     ,  config_class=lowercase_     ,  has_text_modality=lowercase_					)






      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		Optional[Any]:
             """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		:	int					)   ->		Dict:
             """simple docstring"""




             _lowerCamelCase			:						Optional[int]            ='resnet18'
             _lowerCamelCase			:						Dict            ='microsoft/resnet-18'

             _lowerCamelCase			:						Optional[Any]            =AutoBackbone.from_pretrained(lowercase_     ,  use_timm_backbone=lowercase_					)
             _lowerCamelCase			:						List[str]            =AutoBackbone.from_pretrained(lowercase_					)

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

             _lowerCamelCase			:						Union[str, Any]            =AutoBackbone.from_pretrained(lowercase_     ,  use_timm_backbone=lowercase_     ,  out_indices=[1, 2, 3]					)
             _lowerCamelCase			:						Optional[int]            =AutoBackbone.from_pretrained(lowercase_     ,  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		:	List[Any]					)   ->		List[str]:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'					)
      def 			lowerCamelCase			(   self		:	str					)   ->		List[Any]:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone initialization is managed on the timm side'					)
      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		Union[str, Any]:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'					)
      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Union[str, Any]:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'					)
      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Optional[Any]:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'					)
      def 			lowerCamelCase			(   self		:	str					)   ->		Optional[Any]:
             """simple docstring"""




             pass






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




             pass






      @unittest.skip('model weights aren\'t tied in TimmBackbone.'					)
      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		Dict:
             """simple docstring"""




             pass






      @unittest.skip('model weights aren\'t tied in TimmBackbone.'					)
      def 			lowerCamelCase			(   self		:	Dict					)   ->		Union[str, Any]:
             """simple docstring"""




             pass






      @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'					)
      def 			lowerCamelCase			(   self		:	Any					)   ->		str:
             """simple docstring"""




             pass






      @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'					)
      def 			lowerCamelCase			(   self		:	Any					)   ->		Tuple:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'					)
      def 			lowerCamelCase			(   self		:	int					)   ->		str:
             """simple docstring"""




             pass






      @unittest.skip('TimmBackbone doesn\'t support output_attentions.'					)
      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		List[Any]:
             """simple docstring"""




             pass






      @unittest.skip('Safetensors is not supported by timm.'					)
      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		int:
             """simple docstring"""




             pass






      @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'					)
      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		int:
             """simple docstring"""




             pass






      def 			lowerCamelCase			(   self		:	List[str]					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase      ,	_lowerCamelCase			:						List[Any]            =self.model_tester.prepare_config_and_inputs_for_common()

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

                    _lowerCamelCase			:						Union[str, Any]            =['pixel_values']
                    self.assertListEqual(arg_names[:1]     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		str:
             """simple docstring"""




             _lowerCamelCase      ,	_lowerCamelCase			:						Optional[Any]            =self.model_tester.prepare_config_and_inputs_for_common()
             _lowerCamelCase			:						List[str]            =True
             _lowerCamelCase			:						int            =self.has_attentions

             # no need to test all models as different heads yield the same functionality
             _lowerCamelCase			:						Tuple            =self.all_model_classes[0]
             _lowerCamelCase			:						Optional[Any]            =model_class(lowercase_					)
             model.to(lowercase_					)

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

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

             if self.has_attentions:
                    _lowerCamelCase			:						Union[str, Any]            =outputs.attentions[0]
                    attentions.retain_grad()

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

             self.assertIsNotNone(hidden_states.grad					)

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






      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		Optional[int]:
             """simple docstring"""




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

             for model_class in self.all_model_classes:
                    _lowerCamelCase			:						Dict            =model_class(lowercase_					)
                    model.to(lowercase_					)
                    model.eval()
                    _lowerCamelCase			:						List[str]            =model(**lowercase_					)

                    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
                    _lowerCamelCase			:						List[Any]            =copy.deepcopy(lowercase_					)
                    _lowerCamelCase			:						Tuple            =None
                    _lowerCamelCase			:						Union[str, Any]            =model_class(lowercase_					)
                    model.to(lowercase_					)
                    model.eval()
                    _lowerCamelCase			:						Optional[int]            =model(**lowercase_					)

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

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






def       a_ (       SCREAMING_SNAKE_CASE__   : bytes	):
       '''simple docstring'''





       return "".join([hex(SCREAMING_SNAKE_CASE__	)[2:].zfill(2	).upper() for byte in list(SCREAMING_SNAKE_CASE__	)]	)




def       a_ (       SCREAMING_SNAKE_CASE__   : str	):
       '''simple docstring'''





       if (len(SCREAMING_SNAKE_CASE__	) % 2) != 0:
              raise ValueError(
                  'Base16 encoded data is invalid:\nData does not have an even number of hex digits.'	)
       # Check the character set - the standard base16 alphabet
       # is uppercase according to RFC3548 section 6
       if not set(SCREAMING_SNAKE_CASE__	) <= set('0123456789ABCDEF'	):
              raise ValueError(
                  'Base16 encoded data is invalid:\nData is not uppercase hex or it contains invalid characters.'	)
       # For every two hexadecimal digits (= a byte), turn it into an integer.
       # Then, string the result together into bytes, and return it.
       return bytes(int(data[i] + data[i + 1]						,     16	) for i in range(0						,     len(SCREAMING_SNAKE_CASE__	)						,     2	)	)


if __name__ == "__main__":
 import doctest

 doctest.testmod()


