





import unittest

from parameterized import parameterized

from transformers import LlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer

class 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      int				,			a__       :      Optional[int]				,			a__       :      List[Any]=13				,			a__       :      Dict=7				,			a__       :      str=True				,			a__       :      str=True				,			a__       :      Optional[int]=False				,			a__       :      Optional[int]=True				,			a__       :      Union[str, Any]=99				,			a__       :      Optional[int]=32				,			a__       :      Optional[int]=5				,			a__       :      Optional[Any]=4				,			a__       :      str=37				,			a__       :      Union[str, Any]="gelu"				,			a__       :      int=0.1				,			a__       :      List[Any]=0.1				,			a__       :      Dict=512				,			a__       :      Optional[int]=16				,			a__       :      List[Any]=2				,			a__       :      str=0.0_2				,			a__       :      int=3				,			a__       :      Tuple=4				,			a__       :      Optional[Any]=None				,			):





         """simple docstring"""



         __snake_case							       =   parent
         __snake_case							       =   batch_size
         __snake_case							       =   seq_length
         __snake_case							       =   is_training
         __snake_case							       =   use_input_mask
         __snake_case							       =   use_token_type_ids
         __snake_case							       =   use_labels
         __snake_case							       =   vocab_size
         __snake_case							       =   hidden_size
         __snake_case							       =   num_hidden_layers
         __snake_case							       =   num_attention_heads
         __snake_case							       =   intermediate_size
         __snake_case							       =   hidden_act
         __snake_case							       =   hidden_dropout_prob
         __snake_case							       =   attention_probs_dropout_prob
         __snake_case							       =   max_position_embeddings
         __snake_case							       =   type_vocab_size
         __snake_case							       =   type_sequence_label_size
         __snake_case							       =   initializer_range
         __snake_case							       =   num_labels
         __snake_case							       =   num_choices
         __snake_case							       =   scope


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   ids_tensor([self.batch_size, self.seq_length]				,			self.vocab_size      )

         __snake_case							       =   None
         if self.use_input_mask:
            __snake_case							       =   random_attention_mask([self.batch_size, self.seq_length]      )

         __snake_case							       =   None
         if self.use_token_type_ids:
            __snake_case							       =   ids_tensor([self.batch_size, self.seq_length]				,			self.type_vocab_size      )

         __snake_case							       =   None
         __snake_case							       =   None
         __snake_case							       =   None
         if self.use_labels:
            __snake_case							       =   ids_tensor([self.batch_size]				,			self.type_sequence_label_size      )
            __snake_case							       =   ids_tensor([self.batch_size, self.seq_length]				,			self.num_labels      )
            __snake_case							       =   ids_tensor([self.batch_size]				,			self.num_choices      )

         __snake_case							       =   self.get_config()

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


      def    a (self       :      str      ):





         """simple docstring"""



         return LlamaConfig(
             vocab_size=self.vocab_size				,			hidden_size=self.hidden_size				,			num_hidden_layers=self.num_hidden_layers				,			num_attention_heads=self.num_attention_heads				,			intermediate_size=self.intermediate_size				,			hidden_act=self.hidden_act				,			hidden_dropout_prob=self.hidden_dropout_prob				,			attention_probs_dropout_prob=self.attention_probs_dropout_prob				,			max_position_embeddings=self.max_position_embeddings				,			type_vocab_size=self.type_vocab_size				,			is_decoder=a__				,			initializer_range=self.initializer_range				,			)


      def    a (self       :      str				,			a__       :      int				,			a__       :      str				,			a__       :      Union[str, Any]				,			a__       :      Optional[Any]				,			a__       :      Optional[int]				,			a__       :      Optional[Any]				,			a__       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   LlamaModel(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__      )
         __snake_case							       =   model(a__      )
         self.parent.assertEqual(result.last_hidden_state.shape				,			(self.batch_size, self.seq_length, self.hidden_size)      )


      def    a (self       :      Optional[Any]				,			a__       :      str				,			a__       :      List[Any]				,			a__       :      Dict				,			a__       :      Any				,			a__       :      Tuple				,			a__       :      Optional[int]				,			a__       :      List[str]				,			a__       :      Optional[Any]				,			a__       :      Dict				,			):





         """simple docstring"""



         __snake_case							       =   True
         __snake_case							       =   LlamaModel(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			)
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			)
         __snake_case							       =   model(a__				,			attention_mask=a__      )
         self.parent.assertEqual(result.last_hidden_state.shape				,			(self.batch_size, self.seq_length, self.hidden_size)      )


      def    a (self       :      Any				,			a__       :      Union[str, Any]				,			a__       :      Tuple				,			a__       :      Tuple				,			a__       :      int				,			a__       :      int				,			a__       :      str				,			a__       :      int				,			a__       :      List[Any]				,			a__       :      List[Any]				,			):





         """simple docstring"""



         __snake_case							       =   LlamaForCausalLM(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.seq_length, self.vocab_size)      )


      def    a (self       :      int				,			a__       :      str				,			a__       :      Tuple				,			a__       :      Union[str, Any]				,			a__       :      Optional[int]				,			a__       :      Any				,			a__       :      str				,			a__       :      Optional[int]				,			a__       :      Union[str, Any]				,			a__       :      int				,			):





         """simple docstring"""



         __snake_case							       =   True
         __snake_case							       =   True
         __snake_case							       =   LlamaForCausalLM(config=a__      )
         model.to(a__      )
         model.eval()

         # first forward pass
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			use_cache=a__				,			)
         __snake_case							       =   outputs.past_key_values

         # create hypothetical multiple next token and extent to next_input_ids
         __snake_case							       =   ids_tensor((self.batch_size, 3)				,			config.vocab_size      )
         __snake_case							       =   ids_tensor((self.batch_size, 3)				,			vocab_size=2      )

         # append to next input_ids and
         __snake_case							       =   torch.cat([input_ids, next_tokens]				,			dim=-1      )
         __snake_case							       =   torch.cat([input_mask, next_mask]				,			dim=-1      )

         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			output_hidden_states=a__				,			)['''hidden_states'''][0]
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			past_key_values=a__				,			output_hidden_states=a__				,			)['''hidden_states'''][0]

         # select random slice
         __snake_case							       =   ids_tensor((1,)				,			output_from_past.shape[-1]      ).item()
         __snake_case							       =   output_from_no_past[:, -3:, random_slice_idx].detach()
         __snake_case							       =   output_from_past[:, :, random_slice_idx].detach()

         self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]      )

         # test that outputs are equal for slice
         self.parent.assertTrue(torch.allclose(a__				,			a__				,			atol=1E-3      )      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.prepare_config_and_inputs()
         (
             (
             __snake_case
         )       ,	(
             __snake_case
         )       ,	(
             __snake_case
         )       ,	(
             __snake_case
         )       ,	(
             __snake_case
         )       ,	(
             __snake_case
         )       ,	(
             __snake_case
         )       ,	
         )							       =   config_and_inputs
         __snake_case							       =   {'''input_ids''': input_ids, '''attention_mask''': input_mask}
         return config, inputs_dict






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				List[Any]							=    (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
      A_						:				List[str]							=    (LlamaForCausalLM,) if is_torch_available() else ()
      A_						:				Dict							=    (
          {
              'feature-extraction': LlamaModel,
              'text-classification': LlamaForSequenceClassification,
              'text-generation': LlamaForCausalLM,
              'zero-shot': LlamaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      A_						:				Any							=    False
      A_						:				Union[str, Any]							=    False


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         __snake_case							       =   LlamaModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			hidden_size=37      )


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         self.config_tester.run_common_tests()


      def    a (self       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a__      )


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
            __snake_case							       =   type
            self.model_tester.create_and_check_model(*a__      )


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   3
         __snake_case							       =   input_dict['''input_ids''']
         __snake_case							       =   input_ids.ne(1      ).to(a__      )
         __snake_case							       =   ids_tensor([self.model_tester.batch_size]				,			self.model_tester.type_sequence_label_size      )
         __snake_case							       =   LlamaForSequenceClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.assertEqual(result.logits.shape				,			(self.model_tester.batch_size, self.model_tester.num_labels)      )


      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   3
         __snake_case							       =   '''single_label_classification'''
         __snake_case							       =   input_dict['''input_ids''']
         __snake_case							       =   input_ids.ne(1      ).to(a__      )
         __snake_case							       =   ids_tensor([self.model_tester.batch_size]				,			self.model_tester.type_sequence_label_size      )
         __snake_case							       =   LlamaForSequenceClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.assertEqual(result.logits.shape				,			(self.model_tester.batch_size, self.model_tester.num_labels)      )


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   3
         __snake_case							       =   '''multi_label_classification'''
         __snake_case							       =   input_dict['''input_ids''']
         __snake_case							       =   input_ids.ne(1      ).to(a__      )
         __snake_case							       =   ids_tensor(
             [self.model_tester.batch_size, config.num_labels]				,			self.model_tester.type_sequence_label_size      ).to(torch.float      )
         __snake_case							       =   LlamaForSequenceClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.assertEqual(result.logits.shape				,			(self.model_tester.batch_size, self.model_tester.num_labels)      )


      @unittest.skip('''LLaMA buffers include complex numbers, which breaks this test'''      )
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         pass


      @parameterized.expand([('''linear''',), ('''dynamic''',)]      )
      def    a (self       :      Optional[Any]				,			a__       :      Optional[int]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   ids_tensor([1, 10]				,			config.vocab_size      )
         __snake_case							       =   ids_tensor([1, int(config.max_position_embeddings * 1.5      )]				,			config.vocab_size      )

         set_seed(42      )  # Fixed seed at init time so the two models get the same random weights
         __snake_case							       =   LlamaModel(a__      )
         original_model.to(a__      )
         original_model.eval()
         __snake_case							       =   original_model(a__      ).last_hidden_state
         __snake_case							       =   original_model(a__      ).last_hidden_state

         set_seed(42      )  # Fixed seed at init time so the two models get the same random weights
         __snake_case							       =   {'''type''': scaling_type, '''factor''': 1_0.0}
         __snake_case							       =   LlamaModel(a__      )
         scaled_model.to(a__      )
         scaled_model.eval()
         __snake_case							       =   scaled_model(a__      ).last_hidden_state
         __snake_case							       =   scaled_model(a__      ).last_hidden_state

         # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
         # maximum sequence length, so the outputs for the short input should match.
         if scaling_type == "dynamic":
            self.assertTrue(torch.allclose(a__				,			a__				,			atol=1E-5      )      )
         else:
            self.assertFalse(torch.allclose(a__				,			a__				,			atol=1E-5      )      )

         # The output should be different for long inputs
         self.assertFalse(torch.allclose(a__				,			a__				,			atol=1E-5      )      )






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):


      @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''      )
      @slow
      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-7b-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor([input_ids]      )      )
         # Expected mean on dim = -1
         __snake_case							       =   torch.tensor([[-6.6_5_5_0, -4.1_2_2_7, -4.9_8_5_9, -3.2_4_0_6, 0.8_2_6_2, -3.0_0_3_3, 1.2_9_6_4, -3.3_6_9_9]]      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         __snake_case							       =   torch.tensor([-1_2.8_2_8_1, -7.4_4_5_3, -0.4_6_3_9, -8.0_6_2_5, -7.2_5_0_0, -8.0_0_0_0, -6.4_8_8_3, -7.7_6_9_5, -7.8_4_3_8, -7.0_3_1_2, -6.2_1_8_8, -7.1_3_2_8, -1.8_4_9_6, 1.9_9_6_1, -8.6_2_5_0, -6.7_2_2_7, -1_2.8_2_8_1, -6.9_4_9_2, -7.0_7_4_2, -7.7_8_5_2, -7.5_8_2_0, -7.9_0_6_2, -6.9_3_7_5, -7.9_8_0_5, -8.3_4_3_8, -8.1_5_6_2, -8.0_4_6_9, -7.6_2_5_0, -7.7_4_2_2, -7.3_3_9_8,]      )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :30]				,			a__				,			atol=1E-5				,			rtol=1E-5      )


      @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''      )
      @slow
      def    a (self       :      str      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor(a__      )      )
         # Expected mean on dim = -1
         __snake_case							       =   torch.tensor([[-2.0_6_2_2, -1.2_7_9_4, -1.1_6_3_8, -0.9_7_8_8, -1.4_6_0_3, -1.0_2_3_8, -1.7_8_9_3, -1.4_4_1_1]]      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         __snake_case							       =   torch.tensor([-8.1_4_0_6, -8.0_5_4_7, 2.7_4_6_1, -1.2_3_4_4, -0.1_4_4_8, -1.8_2_6_2, -1.0_0_2_0, -1.8_1_5_4, -1.6_8_9_5, -1.8_5_1_6, -2.3_5_7_4, -0.9_2_7_7, 3.7_5_9_8, 6.5_7_4_2, -1.2_9_9_8, -0.1_1_7_7, -8.1_4_0_6, -2.9_6_8_8, -2.9_1_9_9, -3.1_6_9_9, -3.5_2_5_4, -2.3_5_5_5, -2.7_9_8_8, -3.4_1_4_1, -2.8_2_6_2, -4.5_1_9_5, -3.3_3_7_9, -3.3_1_6_4, -2.7_8_3_2, -3.0_2_7_3]      )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :30]				,			a__				,			atol=1E-5				,			rtol=1E-5      )


      @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''      )
      @slow
      def    a (self       :      Any      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor(a__      )      )
         # Expected mean on dim = -1
         __snake_case							       =   torch.tensor([[-0.8_5_6_2, -1.8_5_2_0, -0.7_5_5_1, -0.4_1_6_2, -1.5_1_6_1, -1.2_0_3_8, -2.4_8_2_3, -2.3_2_5_4]]      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         __snake_case							       =   torch.tensor([-2.2_2_2_7, 4.8_8_2_8, 0.9_0_2_3, -0.4_5_7_8, -0.7_8_7_1, -0.1_0_3_3, -0.6_2_2_1, -0.5_7_8_6, -0.7_8_0_3, -1.0_6_7_4, -1.2_9_2_0, -0.1_5_7_0, 0.8_0_0_8, 2.0_7_2_3, -0.9_4_9_7, 0.2_7_7_1, -2.2_2_2_7, -0.7_6_1_2, -1.4_3_4_6, -1.2_0_6_1, -1.6_4_2_6, -0.3_0_0_0, -0.7_1_3_9, -1.1_9_3_4, -1.8_6_9_1, -1.6_9_7_3, -1.5_9_4_7, -1.2_7_0_5, -0.3_5_2_3, -0.5_5_1_3]      )
         # fmt: on
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )


      @unittest.skip(
          '''Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test'''      )
      @slow
      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-70b-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor(a__      )      )

         __snake_case							       =   torch.tensor(
             [[-4.2_3_2_7, -3.3_3_6_0, -4.6_6_6_5, -4.7_6_3_1, -1.8_1_8_0, -3.4_1_7_0, -1.4_2_1_1, -3.1_8_1_0]]				,			dtype=torch.floataa      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # fmt: off
         __snake_case							       =   torch.tensor([-9.4_9_2_2, -3.9_5_5_1, 1.7_9_9_8, -5.6_7_5_8, -5.1_0_5_5, -5.8_9_8_4, -4.8_3_2_0, -6.8_0_8_6, -6.5_3_9_1, -5.6_1_7_2, -5.5_8_2_0, -5.5_3_5_2, 1.7_8_8_1, 3.6_2_8_9, -6.5_1_1_7, -3.4_7_8_5, -9.5_0_0_0, -6.0_3_5_2, -6.8_1_2_5, -6.0_1_9_5, -6.6_8_3_6, -5.4_7_2_7, -6.2_8_1_2, -6.0_3_9_1, -7.3_3_9_8, -7.4_2_9_7, -7.4_8_4_4, -6.5_8_2_0, -5.8_7_8_9, -5.5_3_1_2]      )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :30]				,			a__				,			atol=1E-5				,			rtol=1E-5      )


      @unittest.skip('''Model is curently gated'''      )
      @slow
      def    a (self       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   '''Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the "princi'''
         __snake_case							       =   '''Simply put, the theory of relativity states that '''
         __snake_case							       =   LlamaTokenizer.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''      )
         __snake_case							       =   tokenizer.encode(a__				,			return_tensors='''pt'''      )
         __snake_case							       =   LlamaForCausalLM.from_pretrained(
             '''meta-llama/Llama-2-13b-chat-hf'''				,			device_map='''sequential'''				,			use_safetensors=a__      )

         # greedy generation outputs
         __snake_case							       =   model.generate(a__				,			max_new_tokens=64				,			top_p=a__				,			temperature=1				,			do_sample=a__      )
         __snake_case							       =   tokenizer.decode(generated_ids[0]				,			skip_special_tokens=a__      )
         self.assertEqual(a__				,			a__      )








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 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      str				,			a__       :      Dict				,			a__       :      Tuple=None				,			a__       :      List[Any]=None				,			a__       :      Dict=None				,			a__       :      Union[str, Any]="resnet50"				,			a__       :      Dict=3				,			a__       :      str=32				,			a__       :      int=3				,			a__       :      Dict=True				,			a__       :      Any=True				,			):





         """simple docstring"""



         __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    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         __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    a (self       :      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    a (self       :      List[Any]				,			a__       :      int				,			a__       :      int      ):





         """simple docstring"""



         __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], 14, 14)				,			)


      def    a (self       :      str      ):





         """simple docstring"""



         __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 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				Union[str, Any]							=    (TimmBackbone,) if is_torch_available() else ()
      A_						:				Optional[Any]							=    {'feature-extraction': TimmBackbone} if is_torch_available() else {}
      A_						:				List[Any]							=    False
      A_						:				Dict							=    False
      A_						:				Any							=    False
      A_						:				List[Any]							=    False


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   TimmBackboneModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			has_text_modality=a__      )


      def    a (self       :      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    a (self       :      int      ):





         """simple docstring"""



         __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    a (self       :      str      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone initialization is managed on the timm side'''      )
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


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





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      Dict      ):





         """simple docstring"""



         pass


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





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''Safetensors is not supported by timm.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __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    a (self       :      Dict      ):





         """simple docstring"""



         __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    a (self       :      Optional[int]      ):





         """simple docstring"""



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

