






from binascii import hexlify
from hashlib import shaaaa
from os import urandom

# RFC 3526 - More Modular Exponential (MODP) Diffie-Hellman groups for
# Internet Key Exchange (IKE) https://tools.ietf.org/html/rfc3526

SCREAMING_SNAKE_CASE__		:							Union[str, Any] 				=				{
    # 1536-bit
    5: {
        """prime""": int(
            """FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"""
            + """29024E088A67CC74020BBEA63B139B22514A08798E3404DD"""
            + """EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"""
            + """E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"""
            + """EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"""
            + """C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"""
            + """83655D23DCA3AD961C62F356208552BB9ED529077096966D"""
            + """670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF""",
            base=16,
        ),
        """generator""": 2,
    },
    # 2048-bit
    14: {
        """prime""": int(
            """FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"""
            + """29024E088A67CC74020BBEA63B139B22514A08798E3404DD"""
            + """EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"""
            + """E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"""
            + """EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"""
            + """C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"""
            + """83655D23DCA3AD961C62F356208552BB9ED529077096966D"""
            + """670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"""
            + """E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"""
            + """DE2BCBF6955817183995497CEA956AE515D2261898FA0510"""
            + """15728E5A8AACAA68FFFFFFFFFFFFFFFF""",
            base=16,
        ),
        """generator""": 2,
    },
    # 3072-bit
    15: {
        """prime""": int(
            """FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"""
            + """29024E088A67CC74020BBEA63B139B22514A08798E3404DD"""
            + """EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"""
            + """E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"""
            + """EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"""
            + """C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"""
            + """83655D23DCA3AD961C62F356208552BB9ED529077096966D"""
            + """670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"""
            + """E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"""
            + """DE2BCBF6955817183995497CEA956AE515D2261898FA0510"""
            + """15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"""
            + """ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"""
            + """ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"""
            + """F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"""
            + """BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"""
            + """43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF""",
            base=16,
        ),
        """generator""": 2,
    },
    # 4096-bit
    16: {
        """prime""": int(
            """FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"""
            + """29024E088A67CC74020BBEA63B139B22514A08798E3404DD"""
            + """EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"""
            + """E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"""
            + """EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"""
            + """C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"""
            + """83655D23DCA3AD961C62F356208552BB9ED529077096966D"""
            + """670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"""
            + """E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"""
            + """DE2BCBF6955817183995497CEA956AE515D2261898FA0510"""
            + """15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"""
            + """ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"""
            + """ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"""
            + """F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"""
            + """BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"""
            + """43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"""
            + """88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"""
            + """2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"""
            + """287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"""
            + """1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"""
            + """93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"""
            + """FFFFFFFFFFFFFFFF""",
            base=16,
        ),
        """generator""": 2,
    },
    # 6144-bit
    17: {
        """prime""": int(
            """FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"""
            + """8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"""
            + """302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"""
            + """A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"""
            + """49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"""
            + """FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"""
            + """670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"""
            + """180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"""
            + """3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"""
            + """04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"""
            + """B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"""
            + """1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"""
            + """BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"""
            + """E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"""
            + """99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"""
            + """04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"""
            + """233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"""
            + """D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"""
            + """36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"""
            + """AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"""
            + """DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"""
            + """2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"""
            + """F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"""
            + """BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"""
            + """CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"""
            + """B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"""
            + """387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"""
            + """6DCC4024FFFFFFFFFFFFFFFF""",
            base=16,
        ),
        """generator""": 2,
    },
    # 8192-bit
    18: {
        """prime""": int(
            """FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"""
            + """29024E088A67CC74020BBEA63B139B22514A08798E3404DD"""
            + """EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"""
            + """E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"""
            + """EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"""
            + """C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"""
            + """83655D23DCA3AD961C62F356208552BB9ED529077096966D"""
            + """670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"""
            + """E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"""
            + """DE2BCBF6955817183995497CEA956AE515D2261898FA0510"""
            + """15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"""
            + """ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"""
            + """ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"""
            + """F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"""
            + """BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"""
            + """43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"""
            + """88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"""
            + """2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"""
            + """287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"""
            + """1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"""
            + """93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"""
            + """36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"""
            + """F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"""
            + """179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"""
            + """DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"""
            + """5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"""
            + """D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"""
            + """23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"""
            + """CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"""
            + """06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"""
            + """DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"""
            + """12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"""
            + """38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"""
            + """741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"""
            + """3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"""
            + """22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"""
            + """4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"""
            + """062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"""
            + """4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"""
            + """B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"""
            + """4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"""
            + """9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"""
            + """60C980DD98EDD3DFFFFFFFFFFFFFFFFF""",
            base=16,
        ),
        """generator""": 2,
    },
}







class 				UpperCAmelCase_  :




     def __init__(				self	,						_lowerCAmelCase = 14		):
          if group not in primes:
               raise ValueError("""Unsupported Group"""		)
          UpperCAmelCase__      :  Any				      =			primes[group]["""prime"""]
          UpperCAmelCase__      :  List[str]				      =			primes[group]["""generator"""]

          UpperCAmelCase__      :  Any				      =			int(hexlify(urandom(32		)		)	,						base=16		)




     def   __UpperCAmelCase  (				self		):
          return hex(self.__private_key		)[2:]




     def   __UpperCAmelCase  (				self		):
          UpperCAmelCase__      :  Union[str, Any]				      =			pow(self.generator	,						self.__private_key	,						self.prime		)
          return hex(_lowerCAmelCase		)[2:]




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase		):
          # check if the other public key is valid based on NIST SP800-56
          return (
              2 <= key <= self.prime - 2
              and pow(_lowerCAmelCase	,						(self.prime - 1) // 2	,						self.prime		) == 1
          )




     def   __UpperCAmelCase  (				self	,						_lowerCAmelCase		):
          UpperCAmelCase__      :  Union[str, Any]				      =			int(_lowerCAmelCase	,						base=16		)
          if not self.is_valid_public_key(_lowerCAmelCase		):
               raise ValueError("""Invalid public key"""		)
          UpperCAmelCase__      :  Optional[int]				      =			pow(_lowerCAmelCase	,						self.__private_key	,						self.prime		)
          return shaaaa(str(_lowerCAmelCase		).encode()		).hexdigest()




     @staticmethod
     def   __UpperCAmelCase  (				_lowerCAmelCase	,						_lowerCAmelCase		):
          # check if the other public key is valid based on NIST SP800-56
          return (
              2 <= remote_public_key_str <= prime - 2
              and pow(_lowerCAmelCase	,						(prime - 1) // 2	,						_lowerCAmelCase		) == 1
          )




     @staticmethod
     def   __UpperCAmelCase  (				_lowerCAmelCase	,						_lowerCAmelCase	,						_lowerCAmelCase = 14		):
          UpperCAmelCase__      :  Tuple				      =			int(_lowerCAmelCase	,						base=16		)
          UpperCAmelCase__      :  int				      =			int(_lowerCAmelCase	,						base=16		)
          UpperCAmelCase__      :  Union[str, Any]				      =			primes[group]["""prime"""]
          if not DiffieHellman.is_valid_public_key_static(_lowerCAmelCase	,						_lowerCAmelCase		):
               raise ValueError("""Invalid public key"""		)
          UpperCAmelCase__      :  List[Any]				      =			pow(_lowerCAmelCase	,						_lowerCAmelCase	,						_lowerCAmelCase		)
          return shaaaa(str(_lowerCAmelCase		).encode()		).hexdigest()


if __name__ == "__main__":
      import doctest

      doctest.testmod()











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				:     Union[str, Any]					,						snake_case_				:     Dict					,						snake_case_				:     Tuple=None					,						snake_case_				:     List[str]=None					,						snake_case_				:     Union[str, Any]=None					,						snake_case_				:     str="resnet50"					,						snake_case_				:     List[Any]=3					,						snake_case_				:     Optional[int]=32					,						snake_case_				:     Union[str, Any]=3					,						snake_case_				:     Tuple=True					,						snake_case_				:     List[str]=True					,						)->				Optional[Any]:
						__lowerCAmelCase						 =parent
						__lowerCAmelCase						 =out_indices if out_indices is not None else [4]
						__lowerCAmelCase						 =stage_names
						__lowerCAmelCase						 =out_features
						__lowerCAmelCase						 =backbone
						__lowerCAmelCase						 =batch_size
						__lowerCAmelCase						 =image_size
						__lowerCAmelCase						 =num_channels
						__lowerCAmelCase						 =use_pretrained_backbone
						__lowerCAmelCase						 =is_training



	def 		UpperCamelCase				(    self				:     int)->				Dict:
						__lowerCAmelCase						 =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
						__lowerCAmelCase						 =self.get_config()

						return config, pixel_values



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



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






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



	def 		UpperCamelCase				(    self				:     Union[str, Any])->				str:
						__lowerCAmelCase						 =TimmBackboneModelTester(self)
						__lowerCAmelCase						 =ConfigTester(self					,						config_class=snake_case_					,						has_text_modality=snake_case_)



	def 		UpperCamelCase				(    self				:     Tuple)->				Optional[Any]:
						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				:     Any)->				Dict:
						__lowerCAmelCase						 ="""resnet18"""
						__lowerCAmelCase						 ="""microsoft/resnet-18"""

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

						__lowerCAmelCase						 =AutoBackbone.from_pretrained(snake_case_					,						use_timm_backbone=snake_case_					,						out_indices=[1, 2, 3])
						__lowerCAmelCase						 =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 		UpperCamelCase				(    self				:     Dict)->				Any:
						pass



	@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute""")
	def 		UpperCamelCase				(    self				:     Tuple)->				Dict:
						pass



	@unittest.skip("""TimmBackbone initialization is managed on the timm side""")
	def 		UpperCamelCase				(    self				:     Union[str, Any])->				List[str]:
						pass



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



	@unittest.skip("""TimmBackbone models doesn't have inputs_embeds""")
	def 		UpperCamelCase				(    self				:     int)->				int:
						pass



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



	@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""")
	def 		UpperCamelCase				(    self				:     Any)->				Dict:
						pass



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



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



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



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



	@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration.""")
	def 		UpperCamelCase				(    self				:     Any)->				Tuple:
						pass



	@unittest.skip("""TimmBackbone doesn't support output_attentions.""")
	def 		UpperCamelCase				(    self				:     List[Any])->				str:
						pass



	@unittest.skip("""Safetensors is not supported by timm.""")
	def 		UpperCamelCase				(    self				:     Dict)->				Optional[int]:
						pass



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



	def 		UpperCamelCase				(    self				:     int)->				Union[str, Any]:
						__lowerCAmelCase ,						__lowerCAmelCase						 =self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowerCAmelCase						 =["""pixel_values"""]
											self.assertListEqual(arg_names[:1]					,						snake_case_)



	def 		UpperCamelCase				(    self				:     Dict)->				Optional[Any]:
						__lowerCAmelCase ,						__lowerCAmelCase						 =self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase						 =True
						__lowerCAmelCase						 =self.has_attentions

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

						__lowerCAmelCase						 =self._prepare_for_class(snake_case_					,						snake_case_)
						__lowerCAmelCase						 =model(**snake_case_)
						__lowerCAmelCase						 =outputs[0][-1]

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

						if self.has_attentions:
											__lowerCAmelCase						 =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 		UpperCamelCase				(    self				:     Tuple)->				List[Any]:
						__lowerCAmelCase ,						__lowerCAmelCase						 =self.model_tester.prepare_config_and_inputs_for_common()

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

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

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




