
import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
     from transformers import WhisperFeatureExtractor

if is_torch_available():
     import torch

__magic_name__  							=	random.Random()





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase=1.0     ,		__lowerCAmelCase=None     ,		__lowerCAmelCase=None				):
    if rng is None:
        snake_case__    =					global_rng

    snake_case__    =					[]
    for batch_idx in range(shape[0]				):
        values.append([]				)
        for _ in range(shape[1]				):
            values[-1].append(rng.random() * scale				)

    return values




@require_torch
@require_torchaudio
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase=7		,						lowerCamelCase=4_00		,						lowerCamelCase=20_00		,						lowerCamelCase=10		,						lowerCamelCase=1_60		,						lowerCamelCase=8		,						lowerCamelCase=0.0		,						lowerCamelCase=40_00		,						lowerCamelCase=False		,						lowerCamelCase=True		,						):
          snake_case__    =					parent
          snake_case__    =					batch_size
          snake_case__    =					min_seq_length
          snake_case__    =					max_seq_length
          snake_case__    =					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
          snake_case__    =					padding_value
          snake_case__    =					sampling_rate
          snake_case__    =					return_attention_mask
          snake_case__    =					do_normalize
          snake_case__    =					feature_size
          snake_case__    =					chunk_length
          snake_case__    =					hop_length
      def A_      (      self			):
          return {
              "feature_size": self.feature_size,
              "hop_length": self.hop_length,
              "chunk_length": self.chunk_length,
              "padding_value": self.padding_value,
              "sampling_rate": self.sampling_rate,
              "return_attention_mask": self.return_attention_mask,
              "do_normalize": self.do_normalize,
          }



      def A_      (      self		,						lowerCamelCase=False		,						lowerCamelCase=False			):
          def _flatten(lowerCamelCase			):
              return list(itertools.chain(*lowerCamelCase			)			)

          if equal_length:
              snake_case__    =					[floats_list((self.max_seq_length, self.feature_size)			) for _ in range(self.batch_size			)]
          else:
              # make sure that inputs increase in size
              snake_case__    =					[
                  floats_list((x, self.feature_size)			)
                  for x in range(self.min_seq_length		,						self.max_seq_length		,						self.seq_length_diff			)
              ]
          if numpify:
              snake_case__    =					[np.asarray(lowerCamelCase			) for x in speech_inputs]
          return speech_inputs





@require_torch
@require_torchaudio
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       unittest.TestCase			):
      _A    :		Optional[int]     						=  WhisperFeatureExtractor if is_speech_available() else None
      def A_      (      self			):
          snake_case__    =					WhisperFeatureExtractionTester(self			)
      def A_      (      self			):
          snake_case__    =					self.feature_extraction_class(**self.feat_extract_dict			)

          with tempfile.TemporaryDirectory() as tmpdirname:
              snake_case__    =					feat_extract_first.save_pretrained(lowerCamelCase			)[0]
              check_json_file_has_correct_format(lowerCamelCase			)
              snake_case__    =					self.feature_extraction_class.from_pretrained(lowerCamelCase			)

          snake_case__    =					feat_extract_first.to_dict()
          snake_case__    =					feat_extract_second.to_dict()
          snake_case__    =					feat_extract_first.mel_filters
          snake_case__    =					feat_extract_second.mel_filters
          self.assertTrue(np.allclose(lowerCamelCase		,						lowerCamelCase			)			)
          self.assertEqual(lowerCamelCase		,						lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.feature_extraction_class(**self.feat_extract_dict			)

          with tempfile.TemporaryDirectory() as tmpdirname:
              snake_case__    =					os.path.join(lowerCamelCase		,						"feat_extract.json"			)
              feat_extract_first.to_json_file(lowerCamelCase			)
              snake_case__    =					self.feature_extraction_class.from_json_file(lowerCamelCase			)

          snake_case__    =					feat_extract_first.to_dict()
          snake_case__    =					feat_extract_second.to_dict()
          snake_case__    =					feat_extract_first.mel_filters
          snake_case__    =					feat_extract_second.mel_filters
          self.assertTrue(np.allclose(lowerCamelCase		,						lowerCamelCase			)			)
          self.assertEqual(lowerCamelCase		,						lowerCamelCase			)
      def A_      (      self			):
          # Tests that all call wrap to encode_plus and batch_encode_plus
          snake_case__    =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
          # create three inputs of length 800, 1000, and 1200
          snake_case__    =					[floats_list((1, x)			)[0] for x in range(8_00		,						14_00		,						2_00			)]
          snake_case__    =					[np.asarray(lowerCamelCase			) for speech_input in speech_inputs]

          # Test feature size
          snake_case__    =					feature_extractor(lowerCamelCase		,						padding="max_length"		,						return_tensors="np"			).input_features
          self.assertTrue(input_features.ndim == 3			)
          self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames			)
          self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size			)

          # Test not batched input
          snake_case__    =					feature_extractor(speech_inputs[0]		,						return_tensors="np"			).input_features
          snake_case__    =					feature_extractor(np_speech_inputs[0]		,						return_tensors="np"			).input_features
          self.assertTrue(np.allclose(lowerCamelCase		,						lowerCamelCase		,						atol=1e-3			)			)

          # Test batched
          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			).input_features
          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			).input_features
          for enc_seq_a, enc_seq_a in zip(lowerCamelCase		,						lowerCamelCase			):
              self.assertTrue(np.allclose(lowerCamelCase		,						lowerCamelCase		,						atol=1e-3			)			)

          # Test 2-D numpy arrays are batched.
          snake_case__    =					[floats_list((1, x)			)[0] for x in (8_00, 8_00, 8_00)]
          snake_case__    =					np.asarray(lowerCamelCase			)
          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			).input_features
          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			).input_features
          for enc_seq_a, enc_seq_a in zip(lowerCamelCase		,						lowerCamelCase			):
              self.assertTrue(np.allclose(lowerCamelCase		,						lowerCamelCase		,						atol=1e-3			)			)

          # Test truncation required
          snake_case__    =					[floats_list((1, x)			)[0] for x in range(2_00		,						(feature_extractor.n_samples + 5_00)		,						2_00			)]
          snake_case__    =					[np.asarray(lowerCamelCase			) for speech_input in speech_inputs]

          snake_case__    =					[x[: feature_extractor.n_samples] for x in speech_inputs]
          snake_case__    =					[np.asarray(lowerCamelCase			) for speech_input in speech_inputs_truncated]

          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			).input_features
          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="np"			).input_features
          for enc_seq_a, enc_seq_a in zip(lowerCamelCase		,						lowerCamelCase			):
              self.assertTrue(np.allclose(lowerCamelCase		,						lowerCamelCase		,						atol=1e-3			)			)
      def A_      (      self			):
          import torch

          snake_case__    =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
          snake_case__    =					np.random.rand(1_00		,						32			).astype(np.floataa			)
          snake_case__    =					np_speech_inputs.tolist()

          for inputs in [py_speech_inputs, np_speech_inputs]:
              snake_case__    =					feature_extractor.pad([{"input_features": inputs}]		,						return_tensors="np"			)
              self.assertTrue(np_processed.input_features.dtype == np.floataa			)
              snake_case__    =					feature_extractor.pad([{"input_features": inputs}]		,						return_tensors="pt"			)
              self.assertTrue(pt_processed.input_features.dtype == torch.floataa			)
      def A_      (      self		,						lowerCamelCase			):
          snake_case__    =					load_dataset("hf-internal-testing/librispeech_asr_dummy"		,						"clean"		,						split="validation"			)
          # automatic decoding with librispeech
          snake_case__    =					ds.sort("id"			).select(range(lowerCamelCase			)			)[:num_samples]["audio"]

          return [x["array"] for x in speech_samples]
      def A_      (      self			):
          # fmt: off
          snake_case__    =					torch.tensor(
              [
                  0.1_1_9_3, -0.0_9_4_6, -0.1_0_9_8, -0.0_1_9_6, 0.0_2_2_5, -0.0_6_9_0, -0.1_7_3_6, 0.0_9_5_1,
                  0.0_9_7_1, -0.0_8_1_7, -0.0_7_0_2, 0.0_1_6_2, 0.0_2_6_0, 0.0_0_1_7, -0.0_1_9_2, -0.1_6_7_8,
                  0.0_7_0_9, -0.1_8_6_7, -0.0_6_5_5, -0.0_2_7_4, -0.0_2_3_4, -0.1_8_8_4, -0.0_5_1_6, -0.0_5_5_4,
                  -0.0_2_7_4, -0.1_4_2_5, -0.1_4_2_3, 0.0_8_3_7, 0.0_3_7_7, -0.0_8_5_4
              ]			)
          # fmt: on

          snake_case__    =					self._load_datasamples(1			)
          snake_case__    =					WhisperFeatureExtractor()
          snake_case__    =					feature_extractor(lowerCamelCase		,						return_tensors="pt"			).input_features
          self.assertEqual(input_features.shape		,						(1, 80, 30_00)			)
          self.assertTrue(torch.allclose(input_features[0, 0, :30]		,						lowerCamelCase		,						atol=1e-4			)			)



      def A_      (      self			):
          snake_case__    =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
          snake_case__    =					self._load_datasamples(1			)[0]
          snake_case__    =					((audio - audio.min()) / (audio.max() - audio.min())) * 6_55_35  # Rescale to [0, 65535] to show issue
          snake_case__    =					feat_extract.zero_mean_unit_var_norm([audio]		,						attention_mask=lowerCamelCase			)[0]

          self.assertTrue(np.all(np.mean(lowerCamelCase			) < 1e-3			)			)
          self.assertTrue(np.all(np.abs(np.var(lowerCamelCase			) - 1			) < 1e-3			)			)





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



