

import copy
import inspect

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

@require_torch
class      _a				:




      """simple docstring"""

      _lowerCamelCase					: Optional[Any]					=					()
      _lowerCamelCase					: Tuple					=					True





      def 		__A  (      self       :							Union[str, Any]  ):
            A_	     =							self.config_class

            # test default config
            A_	     =							config_class()
            self.assertIsNotNone(UpperCAmelCase  )
            A_	     =							["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
            A_	     =							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
            A_	     =							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
            A_	     =							config_class(out_features=["stage1", "stage3"]  )
            self.assertEqual(config.out_features	, ["stage1", "stage3"]  )
            self.assertEqual(config.out_indices	, [1, 3]  )

            # Only out_indices set
            A_	     =							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  ):
                  A_	     =							config_class(out_features=["stage1", "stage2"]	, out_indices=[0, 2]  )





      def 		__A  (      self       :							Optional[int]  ):
            A_     ,    A_	     =							self.model_tester.prepare_config_and_inputs_for_common()

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





      def 		__A  (      self       :							int  ):
            A_     ,    A_	     =							self.model_tester.prepare_config_and_inputs_for_common()

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

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

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





      def 		__A  (      self       :							List[Any]  ):
            A_     ,    A_	     =							self.model_tester.prepare_config_and_inputs_for_common()

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

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

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

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

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





      def 		__A  (      self       :							Optional[int]  ):
            A_     ,    A_	     =							self.model_tester.prepare_config_and_inputs_for_common()

            for backbone_class in self.all_model_classes:
                  A_	     =							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       :							Tuple  ):
            A_     ,    A_	     =							self.model_tester.prepare_config_and_inputs_for_common()
            A_	     =							inputs_dict["pixel_values"].shape[0]

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

                  A_	     =							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
                  A_	     =							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:
                        A_	     =							backbone(**UpperCAmelCase	, output_attentions=UpperCAmelCase  )
                        self.assertIsNotNone(outputs.attentions  )


__a						:Dict            = {hex(i)[2:]: i for i in range(16)}  # Use [:2] to strip off the leading '0x'

def 			__snake_case	(   __UpperCamelCase  :   str						):



      """simple docstring"""

      A_	     =							hex_string.strip().lower()
      if not hex_string:
            raise ValueError("Empty string was passed to the function"						)
      A_	     =							hex_string[0] == "-"
      if is_negative:
            A_	     =							hex_string[1:]
      if not all(char in hex_table for char in hex_string						):
            raise ValueError("Non-hexadecimal value was passed to the function"						)
      A_	     =							0
      for char in hex_string:
            A_	     =							16 * decimal_number + hex_table[char]
      return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
      from doctest import testmod

      testmod()