
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		,						lowerCamelCase		,						lowerCamelCase=13		,						lowerCamelCase=7		,						lowerCamelCase=True		,						lowerCamelCase=True		,						lowerCamelCase=False		,						lowerCamelCase=True		,						lowerCamelCase=99		,						lowerCamelCase=32		,						lowerCamelCase=5		,						lowerCamelCase=4		,						lowerCamelCase=37		,						lowerCamelCase="gelu"		,						lowerCamelCase=0.1		,						lowerCamelCase=0.1		,						lowerCamelCase=5_12		,						lowerCamelCase=16		,						lowerCamelCase=2		,						lowerCamelCase=0.0_2		,						lowerCamelCase=3		,						lowerCamelCase=4		,						lowerCamelCase=None		,						):
          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			):
          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			):
          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=lowerCamelCase		,						initializer_range=self.initializer_range		,						)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					LlamaModel(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase			)
          snake_case__    =					model(lowerCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					True
          snake_case__    =					LlamaModel(lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						encoder_hidden_states=lowerCamelCase		,						encoder_attention_mask=lowerCamelCase		,						)
          snake_case__    =					model(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						encoder_hidden_states=lowerCamelCase		,						)
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					LlamaForCausalLM(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.seq_length, self.vocab_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase		,						):
          snake_case__    =					True
          snake_case__    =					True
          snake_case__    =					LlamaForCausalLM(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()

          # first forward pass
          snake_case__    =					model(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						encoder_hidden_states=lowerCamelCase		,						encoder_attention_mask=lowerCamelCase		,						use_cache=lowerCamelCase		,						)
          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(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						encoder_hidden_states=lowerCamelCase		,						encoder_attention_mask=lowerCamelCase		,						output_hidden_states=lowerCamelCase		,						)["hidden_states"][0]
          snake_case__    =					model(
              lowerCamelCase		,						attention_mask=lowerCamelCase		,						encoder_hidden_states=lowerCamelCase		,						encoder_attention_mask=lowerCamelCase		,						past_key_values=lowerCamelCase		,						output_hidden_states=lowerCamelCase		,						)["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(lowerCamelCase		,						lowerCamelCase		,						atol=1e-3			)			)



      def A_      (      self			):
          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    :		int     						=  (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
      _A    :		Tuple     						=  (LlamaForCausalLM,) if is_torch_available() else ()
      _A    :		List[str]     						=  (
          {
              'feature-extraction': LlamaModel,
              'text-classification': LlamaForSequenceClassification,
              'text-generation': LlamaForCausalLM,
              'zero-shot': LlamaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      _A    :		List[Any]     						=  False
      _A    :		Dict     						=  False
      def A_      (      self			):
          snake_case__    =					LlamaModelTester(self			)
          snake_case__    =					ConfigTester(self		,						config_class=lowerCamelCase		,						hidden_size=37			)
      def A_      (      self			):
          self.config_tester.run_common_tests()
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCamelCase			)
      def A_      (      self			):
          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(*lowerCamelCase			)
      def A_      (      self			):
          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(lowerCamelCase			)
          snake_case__    =					ids_tensor([self.model_tester.batch_size]		,						self.model_tester.type_sequence_label_size			)
          snake_case__    =					LlamaForSequenceClassification(lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase			)
          self.assertEqual(result.logits.shape		,						(self.model_tester.batch_size, self.model_tester.num_labels)			)
      def A_      (      self			):
          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(lowerCamelCase			)
          snake_case__    =					ids_tensor([self.model_tester.batch_size]		,						self.model_tester.type_sequence_label_size			)
          snake_case__    =					LlamaForSequenceClassification(lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase			)
          self.assertEqual(result.logits.shape		,						(self.model_tester.batch_size, self.model_tester.num_labels)			)
      def A_      (      self			):
          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(lowerCamelCase			)
          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(lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						attention_mask=lowerCamelCase		,						labels=lowerCamelCase			)
          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			):
          pass



      @parameterized.expand([("linear",), ("dynamic",)]			)
      def A_      (      self		,						lowerCamelCase			):
          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(lowerCamelCase			)
          original_model.to(lowerCamelCase			)
          original_model.eval()
          snake_case__    =					original_model(lowerCamelCase			).last_hidden_state
          snake_case__    =					original_model(lowerCamelCase			).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(lowerCamelCase			)
          scaled_model.to(lowerCamelCase			)
          scaled_model.eval()
          snake_case__    =					scaled_model(lowerCamelCase			).last_hidden_state
          snake_case__    =					scaled_model(lowerCamelCase			).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(lowerCamelCase		,						lowerCamelCase		,						atol=1e-5			)			)
          else:
              self.assertFalse(torch.allclose(lowerCamelCase		,						lowerCamelCase		,						atol=1e-5			)			)

          # The output should be different for long inputs
          self.assertFalse(torch.allclose(lowerCamelCase		,						lowerCamelCase		,						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			):
          snake_case__    =					[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
          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			)		,						lowerCamelCase		,						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]		,						lowerCamelCase		,						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			):
          snake_case__    =					[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
          snake_case__    =					LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-hf"		,						device_map="auto"			)
          snake_case__    =					model(torch.tensor(lowerCamelCase			)			)
          # 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			)		,						lowerCamelCase		,						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]		,						lowerCamelCase		,						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			):
          snake_case__    =					[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
          snake_case__    =					LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-13b-chat-hf"		,						device_map="auto"			)
          snake_case__    =					model(torch.tensor(lowerCamelCase			)			)
          # 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			)		,						lowerCamelCase		,						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			)		,						lowerCamelCase		,						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			):
          snake_case__    =					[1, 3_06, 46_58, 2_78, 65_93, 3_10, 28_34, 3_38]
          snake_case__    =					LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-70b-hf"		,						device_map="auto"			)
          snake_case__    =					model(torch.tensor(lowerCamelCase			)			)

          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			)		,						lowerCamelCase		,						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]		,						lowerCamelCase		,						atol=1e-5		,						rtol=1e-5			)



      @unittest.skip("Model is curently gated"			)
      @slow
      def A_      (      self			):
          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(lowerCamelCase		,						return_tensors="pt"			)
          snake_case__    =					LlamaForCausalLM.from_pretrained(
              "meta-llama/Llama-2-13b-chat-hf"		,						device_map="sequential"		,						use_safetensors=lowerCamelCase			)

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





import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFEfficientFormerForImageClassification,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerModel,
     )
     from transformers.models.efficientformer.modeling_tf_efficientformer import (
         TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
     )


if is_vision_available():
     from PIL import Image

     from transformers import EfficientFormerImageProcessor




class        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase = 13		,						lowerCamelCase = 64		,						lowerCamelCase = 2		,						lowerCamelCase = 3		,						lowerCamelCase = 3		,						lowerCamelCase = True		,						lowerCamelCase = True		,						lowerCamelCase = 1_28		,						lowerCamelCase=[16, 32, 64, 1_28]		,						lowerCamelCase = 7		,						lowerCamelCase = 4		,						lowerCamelCase = 37		,						lowerCamelCase = "gelu"		,						lowerCamelCase = 0.1		,						lowerCamelCase = 0.1		,						lowerCamelCase = 10		,						lowerCamelCase = 0.0_2		,						lowerCamelCase = 2		,						lowerCamelCase = 1		,						lowerCamelCase = 1_28		,						lowerCamelCase = [2, 2, 2, 2]		,						lowerCamelCase = 2		,						lowerCamelCase = 2		,						):
          snake_case__    =					parent
          snake_case__    =					batch_size
          snake_case__    =					image_size
          snake_case__    =					patch_size
          snake_case__    =					num_channels
          snake_case__    =					is_training
          snake_case__    =					use_labels
          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__    =					type_sequence_label_size
          snake_case__    =					initializer_range
          snake_case__    =					encoder_stride
          snake_case__    =					num_attention_outputs
          snake_case__    =					embed_dim
          snake_case__    =					embed_dim + 1
          snake_case__    =					resolution
          snake_case__    =					depths
          snake_case__    =					hidden_sizes
          snake_case__    =					dim
          snake_case__    =					mlp_expansion_ratio
      def A_      (      self			):
          snake_case__    =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

          snake_case__    =					None
          if self.use_labels:
              snake_case__    =					ids_tensor([self.batch_size]		,						self.type_sequence_label_size			)

          snake_case__    =					self.get_config()

          return config, pixel_values, labels
      def A_      (      self			):
          return EfficientFormerConfig(
              image_size=self.image_size		,						patch_size=self.patch_size		,						num_channels=self.num_channels		,						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		,						is_decoder=lowerCamelCase		,						initializer_range=self.initializer_range		,						encoder_stride=self.encoder_stride		,						resolution=self.resolution		,						depths=self.depths		,						hidden_sizes=self.hidden_sizes		,						dim=self.dim		,						mlp_expansion_ratio=self.mlp_expansion_ratio		,						)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					TFEfficientFormerModel(config=lowerCamelCase			)
          snake_case__    =					model(lowerCamelCase		,						training=lowerCamelCase			)
          self.parent.assertEqual(result.last_hidden_state.shape		,						(self.batch_size, self.seq_length, self.hidden_size)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					self.type_sequence_label_size
          snake_case__    =					TFEfficientFormerForImageClassification(lowerCamelCase			)
          snake_case__    =					model(lowerCamelCase		,						labels=lowerCamelCase		,						training=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.type_sequence_label_size)			)

          # test greyscale images
          snake_case__    =					1
          snake_case__    =					TFEfficientFormerForImageClassification(lowerCamelCase			)

          snake_case__    =					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
          snake_case__    =					model(lowerCamelCase		,						labels=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.type_sequence_label_size)			)



      def A_      (      self			):
          snake_case__    =					self.prepare_config_and_inputs()
          snake_case__    ,       snake_case__    ,       snake_case__    =					config_and_inputs
          snake_case__    =					{"pixel_values": pixel_values}
          return config, inputs_dict





@require_tf
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       __UpperCamelCase							,       unittest.TestCase			):
      _A    :		str     						=  (
          (
              TFEfficientFormerModel,
              TFEfficientFormerForImageClassificationWithTeacher,
              TFEfficientFormerForImageClassification,
          )
          if is_tf_available()
          else ()
      )
      _A    :		List[str]     						=  (
          {
              'feature-extraction': TFEfficientFormerModel,
              'image-classification': (
                  TFEfficientFormerForImageClassification,
                  TFEfficientFormerForImageClassificationWithTeacher,
              ),
          }
          if is_tf_available()
          else {}
      )

      _A    :		Optional[Any]     						=  False

      _A    :		List[Any]     						=  False
      _A    :		Tuple     						=  False
      _A    :		List[Any]     						=  False
      _A    :		Any     						=  False
      def A_      (      self			):
          snake_case__    =					TFEfficientFormerModelTester(self			)
          snake_case__    =					ConfigTester(
              self		,						config_class=lowerCamelCase		,						has_text_modality=lowerCamelCase		,						hidden_size=37			)
      def A_      (      self			):
          self.config_tester.run_common_tests()
      @unittest.skip(reason="EfficientFormer does not use inputs_embeds"			)
      def A_      (      self			):
          pass
      @unittest.skip(reason="EfficientFormer does not support input and output embeddings"			)
      def A_      (      self			):
          pass
      def A_      (      self			):
          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(lowerCamelCase			)
              snake_case__    =					inspect.signature(model.call			)
              # 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]		,						lowerCamelCase			)
      def A_      (      self			):
          def check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
              snake_case__    =					model_class(lowerCamelCase			)

              snake_case__    =					model(**self._prepare_for_class(lowerCamelCase		,						lowerCamelCase			)		,						training=lowerCamelCase			)
              snake_case__    =					outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

              snake_case__    =					getattr(
                  self.model_tester		,						"expected_num_hidden_layers"		,						self.model_tester.num_hidden_layers + 1			)
              self.assertEqual(len(lowerCamelCase			)		,						lowerCamelCase			)

              if hasattr(self.model_tester		,						"encoder_seq_length"			):
                  snake_case__    =					self.model_tester.encoder_seq_length
                  if hasattr(self.model_tester		,						"chunk_length"			) and self.model_tester.chunk_length > 1:
                      snake_case__    =					seq_length * self.model_tester.chunk_length
              else:
                  snake_case__    =					self.model_tester.seq_length

              self.assertListEqual(
                  list(hidden_states[-1].shape[-2:]			)		,						[seq_length, self.model_tester.hidden_size]		,						)

              if config.is_encoder_decoder:
                  snake_case__    =					outputs.decoder_hidden_states

                  self.asseretIsInstance(lowerCamelCase		,						(list, tuple)			)
                  self.assertEqual(len(lowerCamelCase			)		,						lowerCamelCase			)
                  snake_case__    =					getattr(self.model_tester		,						"seq_length"		,						lowerCamelCase			)
                  snake_case__    =					getattr(self.model_tester		,						"decoder_seq_length"		,						lowerCamelCase			)

                  self.assertListEqual(
                      list(hidden_states[-1].shape[-2:]			)		,						[decoder_seq_length, self.model_tester.hidden_size]		,						)

          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              snake_case__    =					True
              check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              snake_case__    =					True

              check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase=False			):
          snake_case__    =					super()._prepare_for_class(lowerCamelCase		,						lowerCamelCase		,						return_labels=lowerCamelCase			)

          if return_labels:
              if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
                  del inputs_dict["labels"]

          return inputs_dict
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCamelCase			)
      @unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowerCamelCase			)
      @slow
      def A_      (      self			):
          for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case__    =					TFEfficientFormerModel.from_pretrained(lowerCamelCase			)
              self.assertIsNotNone(lowerCamelCase			)
      def A_      (      self			):
          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()
          snake_case__    =					True

          snake_case__    =					getattr(self.model_tester		,						"seq_length"		,						lowerCamelCase			)
          snake_case__    =					getattr(self.model_tester		,						"encoder_seq_length"		,						lowerCamelCase			)
          snake_case__    =					getattr(self.model_tester		,						"key_length"		,						lowerCamelCase			)
          snake_case__    =					getattr(self.model_tester		,						"chunk_length"		,						lowerCamelCase			)

          if chunk_length is not None and hasattr(self.model_tester		,						"num_hashes"			):
              snake_case__    =					encoder_seq_length * self.model_tester.num_hashes

          for model_class in self.all_model_classes:
              snake_case__    =					True
              snake_case__    =					False
              snake_case__    =					True
              snake_case__    =					model_class(lowerCamelCase			)

              snake_case__    =					model(**self._prepare_for_class(lowerCamelCase		,						lowerCamelCase			)		,						training=lowerCamelCase			)
              snake_case__    =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(lowerCamelCase			)		,						self.model_tester.num_attention_outputs			)

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              snake_case__    =					True
              snake_case__    =					model_class(lowerCamelCase			)
              snake_case__    =					model(**self._prepare_for_class(lowerCamelCase		,						lowerCamelCase			)		,						training=lowerCamelCase			)

              snake_case__    =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
              self.assertEqual(len(lowerCamelCase			)		,						self.model_tester.num_attention_outputs			)

              if chunk_length is not None:
                  self.assertListEqual(
                      list(attentions[0].shape[-4:]			)		,						[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]		,						)
              else:
                  self.assertListEqual(
                      list(attentions[0].shape[-3:]			)		,						[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]		,						)



      def A_      (      self			):
          # We use a simplified version of this test for EfficientFormer because it requires training=False
          # and Keras refuses to let us force that during functional construction
          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              # Prepare our model
              snake_case__    =					model_class(lowerCamelCase			)
              # These are maximally general inputs for the model, with multiple None dimensions
              # Hopefully this will catch any conditionals that fail for flexible shapes
              snake_case__    =					{
                  key: tf.keras.Input(shape=val.shape[1:]		,						dtype=val.dtype		,						name=lowerCamelCase			)
                  for key, val in model.input_signature.items()
                  if key in model.dummy_inputs
              }
              snake_case__    =					model(lowerCamelCase			)
              self.assertTrue(outputs_dict is not None			)





def 						SCREAMING_SNAKE_CASE__     (   ):
    snake_case__    =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
    return image





@require_tf
@require_vision
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      @cached_property
      def A_      (      self			):
          return (
              EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"			)
              if is_vision_available()
              else None
          )
      @slow
      def A_      (      self			):
          snake_case__    =					TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"			)
          snake_case__    =					self.default_image_processor
          snake_case__    =					prepare_img()
          snake_case__    =					image_processor(images=lowerCamelCase		,						return_tensors="tf"			)
          # forward pass
          snake_case__    =					model(**lowerCamelCase		,						training=lowerCamelCase			)
          # verify the logits
          snake_case__    =					tf.TensorShape((1, 10_00)			)
          self.assertEqual(outputs.logits.shape		,						lowerCamelCase			)
          snake_case__    =					tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]			)
          self.assertTrue(np.allclose(outputs.logits[0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)



      @slow
      def A_      (      self			):
          snake_case__    =					TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
              "snap-research/efficientformer-l1-300"			)
          snake_case__    =					self.default_image_processor
          snake_case__    =					prepare_img()
          snake_case__    =					image_processor(images=lowerCamelCase		,						return_tensors="tf"			)
          # forward pass
          snake_case__    =					model(**lowerCamelCase		,						training=lowerCamelCase			)
          # verify the logits
          snake_case__    =					tf.TensorShape((1, 10_00)			)
          self.assertEqual(outputs.logits.shape		,						lowerCamelCase			)
          snake_case__    =					tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]			)
          self.assertTrue(np.allclose(outputs.logits[0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)



