




import gc
import unittest

import numpy as np
import torch

from diffusers import DDPMScheduler, MidiProcessor, SpectrogramDiffusionPipeline
from diffusers.pipelines.spectrogram_diffusion import SpectrogramContEncoder, SpectrogramNotesEncoder, TaFilmDecoder
from diffusers.utils import require_torch_gpu, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_note_seq, require_onnxruntime

from ..pipeline_params import TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS, TOKENS_TO_AUDIO_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


_SCREAMING_SNAKE_CASE =	"""./tests/fixtures/elise_format0.mid"""
@unittest.skip("""The note-seq package currently throws an error on import"""							)
class      __UpperCAmelCase							(    snake_case__ ,unittest.TestCase							):



					'''simple docstring'''





					_UpperCamelCase  	=		SpectrogramDiffusionPipeline
					_UpperCamelCase  	=		PipelineTesterMixin.required_optional_params - {
					    'callback',
					    'latents',
					    'callback_steps',
					    'output_type',
					    'num_images_per_prompt',
					}
					_UpperCamelCase  	=		False
					_UpperCamelCase  	=		False
					_UpperCamelCase  	=		TOKENS_TO_AUDIO_GENERATION_PARAMS
					_UpperCamelCase  	=		TOKENS_TO_AUDIO_GENERATION_BATCH_PARAMS



					def 						__snake_case	(  self    :	Dict)						->       str:
								torch.manual_seed(0)
								A_       		=   SpectrogramNotesEncoder(
								    max_length=2_048			,					vocab_size=1_536			,					d_model=768			,					dropout_rate=0.1			,					num_layers=1			,					num_heads=1			,					d_kv=4			,					d_ff=2_048			,					feed_forward_proj='gated-gelu'			,					)

								A_       		=   SpectrogramContEncoder(
								    input_dims=128			,					targets_context_length=256			,					d_model=768			,					dropout_rate=0.1			,					num_layers=1			,					num_heads=1			,					d_kv=4			,					d_ff=2_048			,					feed_forward_proj='gated-gelu'			,					)

								A_       		=   TaFilmDecoder(
								    input_dims=128			,					targets_length=256			,					max_decoder_noise_time=20_000.0			,					d_model=768			,					num_layers=1			,					num_heads=1			,					d_kv=4			,					d_ff=2_048			,					dropout_rate=0.1			,					)

								A_       		=   DDPMScheduler()

								A_       		=   {
								    'notes_encoder': notes_encoder.eval(),
								    'continuous_encoder': continuous_encoder.eval(),
								    'decoder': decoder.eval(),
								    'scheduler': scheduler,
								    'melgan': None,
								}
								return components



					def 						__snake_case	(  self    :	Any			,					_lowercase    :	Any			,					_lowercase    :	int=0)						->       Optional[Any]:
								if str(_lowercase).startswith('mps'):
											A_       		=   torch.manual_seed(_lowercase)
								else:
											A_       		=   torch.Generator(device=_lowercase).manual_seed(_lowercase)
								A_       		=   {
								    'input_tokens': [
								        [1_134, 90, 1_135, 1_133, 1_080, 112, 1_132, 1_080, 1_133, 1_079, 133, 1_132, 1_079, 1_133, 1] + [0] * 2_033
								    ],
								    'generator': generator,
								    'num_inference_steps': 4,
								    'output_type': 'mel',
								}
								return inputs



					def 						__snake_case	(  self    :	Dict)						->       List[Any]:
								A_       		=   'cpu'  # ensure determinism for the device-dependent torch.Generator
								A_       		=   self.get_dummy_components()
								A_       		=   SpectrogramDiffusionPipeline(**_lowercase)
								A_       		=   pipe.to(_lowercase)
								pipe.set_progress_bar_config(disable=_lowercase)

								A_       		=   self.get_dummy_inputs(_lowercase)
								A_       		=   pipe(**_lowercase)
								A_       		=   output.audios

								A_       		=   mel[0, -3:, -3:]

								assert mel_slice.shape == (3, 3)
								A_       		=   np.array(
								    [-11.51_29_25, -4.78_82_15, -0.46_17_29_05, -2.05_17_15, -10.53_91_47, -10.97_09_63, -9.09_16_34, 4.0, 4.0])
								assert np.abs(mel_slice.flatten() - expected_slice).max() < 1E-2



					@skip_mps
					def 						__snake_case	(  self    :	Any)						->       Union[str, Any]:
								return super().test_save_load_local()



					@skip_mps
					def 						__snake_case	(  self    :	Tuple)						->       Union[str, Any]:
								return super().test_dict_tuple_outputs_equivalent()



					@skip_mps
					def 						__snake_case	(  self    :	Dict)						->       Dict:
								return super().test_save_load_optional_components()



					@skip_mps
					def 						__snake_case	(  self    :	str)						->       List[Any]:
								return super().test_attention_slicing_forward_pass()



					def 						__snake_case	(  self    :	Any)						->       List[Any]:
								pass



					def 						__snake_case	(  self    :	Optional[int])						->       Any:
								pass



					@skip_mps
					def 						__snake_case	(  self    :	Optional[Any])						->       Union[str, Any]:
								return super().test_progress_bar()





@slow
@require_torch_gpu
@require_onnxruntime
@require_note_seq
class      __UpperCAmelCase							(    unittest.TestCase							):



					'''simple docstring'''





					def 						__snake_case	(  self    :	Optional[int])						->       Tuple:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



					def 						__snake_case	(  self    :	str)						->       Any:
								# TODO - test that pipeline can decode tokens in a callback
								# so that music can be played live
								A_       		=   torch_device

								A_       		=   SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion')
								A_       		=   pipe.melgan
								A_       		=   None

								A_       		=   pipe.to(_lowercase)
								pipe.set_progress_bar_config(disable=_lowercase)

								def callback(_lowercase    :	int			,					_lowercase    :	int):
											# decode mel to audio
											A_       		=   melgan(input_features=mel_output.astype(np.floataa))[0]
											assert len(audio[0]) == 81_920 * (step + 1)
											# simulate that audio is played
											return audio

								A_       		=   MidiProcessor()
								A_       		=   processor(_lowercase)

								A_       		=   input_tokens[:3]
								A_       		=   torch.manual_seed(0)
								pipe(_lowercase			,					num_inference_steps=5			,					generator=_lowercase			,					callback=_lowercase			,					output_type='mel')



					def 						__snake_case	(  self    :	str)						->       Any:
								A_       		=   torch_device

								A_       		=   SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion')
								A_       		=   pipe.to(_lowercase)
								pipe.set_progress_bar_config(disable=_lowercase)
								A_       		=   MidiProcessor()

								A_       		=   processor(_lowercase)
								# just run two denoising loops
								A_       		=   input_tokens[:2]

								A_       		=   torch.manual_seed(0)
								A_       		=   pipe(_lowercase			,					num_inference_steps=2			,					generator=_lowercase)

								A_       		=   output.audios[0]

								assert abs(np.abs(_lowercase).sum() - 3_612.841) < 1E-1



					def 						__snake_case	(  self    :	List[Any])						->       str:
								A_       		=   torch_device

								A_       		=   SpectrogramDiffusionPipeline.from_pretrained('google/music-spectrogram-diffusion')
								A_       		=   pipe.to(_lowercase)
								pipe.set_progress_bar_config(disable=_lowercase)

								A_       		=   MidiProcessor()

								A_       		=   processor(_lowercase)

								# just run 4 denoising loops
								A_       		=   input_tokens[:4]

								A_       		=   torch.manual_seed(0)
								A_       		=   pipe(_lowercase			,					num_inference_steps=100			,					generator=_lowercase)

								A_       		=   output.audios[0]
								assert abs(np.abs(_lowercase).sum() - 9_389.1_111) < 5E-2










'''simple docstring'''
import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
							    MODEL_MAPPING,
							    EfficientFormerForImageClassification,
							    EfficientFormerForImageClassificationWithTeacher,
							    EfficientFormerModel,
							)
							from transformers.models.efficientformer.modeling_efficientformer import (
							    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
							)


if is_vision_available():
							from PIL import Image

							from transformers import EfficientFormerImageProcessor
class      __UpperCAmelCase							:



					'''simple docstring'''





					def __init__(  self    :	Optional[int]			,					_lowercase    :	Optional[Any]			,					_lowercase    :	int = 13			,					_lowercase    :	int = 64			,					_lowercase    :	int = 2			,					_lowercase    :	int = 3			,					_lowercase    :	int = 3			,					_lowercase    :	bool = True			,					_lowercase    :	bool = True			,					_lowercase    :	int = 128			,					_lowercase    :	Optional[Any]=[16, 32, 64, 128]			,					_lowercase    :	int = 7			,					_lowercase    :	int = 4			,					_lowercase    :	int = 37			,					_lowercase    :	str = "gelu"			,					_lowercase    :	float = 0.1			,					_lowercase    :	float = 0.1			,					_lowercase    :	int = 10			,					_lowercase    :	float = 0.02			,					_lowercase    :	int = 2			,					_lowercase    :	int = 1			,					_lowercase    :	int = 128			,					_lowercase    :	List[int] = [2, 2, 2, 2]			,					_lowercase    :	int = 2			,					_lowercase    :	int = 2			,					)						->       Any:
								A_       		=   parent
								A_       		=   batch_size
								A_       		=   image_size
								A_       		=   patch_size
								A_       		=   num_channels
								A_       		=   is_training
								A_       		=   use_labels
								A_       		=   hidden_size
								A_       		=   num_hidden_layers
								A_       		=   num_attention_heads
								A_       		=   intermediate_size
								A_       		=   hidden_act
								A_       		=   hidden_dropout_prob
								A_       		=   attention_probs_dropout_prob
								A_       		=   type_sequence_label_size
								A_       		=   initializer_range
								A_       		=   encoder_stride
								A_       		=   num_attention_outputs
								A_       		=   embed_dim
								A_       		=   embed_dim + 1
								A_       		=   resolution
								A_       		=   depths
								A_       		=   hidden_sizes
								A_       		=   dim
								A_       		=   mlp_expansion_ratio



					def 						__snake_case	(  self    :	Union[str, Any])						->       int:
								A_       		=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

								A_       		=   self.get_config()
								return config, pixel_values, labels



					def 						__snake_case	(  self    :	int)						->       Union[str, Any]:
								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=_lowercase			,					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 						__snake_case	(  self    :	str			,					_lowercase    :	Optional[Any]			,					_lowercase    :	Union[str, Any]			,					_lowercase    :	Any)						->       str:
								A_       		=   EfficientFormerModel(config=_lowercase)
								model.to(_lowercase)
								model.eval()
								A_       		=   model(_lowercase)
								self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size))



					def 						__snake_case	(  self    :	Optional[int]			,					_lowercase    :	List[Any]			,					_lowercase    :	List[Any]			,					_lowercase    :	Any)						->       str:
								A_       		=   self.type_sequence_label_size
								A_       		=   EfficientFormerForImageClassification(_lowercase)
								model.to(_lowercase)
								model.eval()
								A_       		=   model(_lowercase			,					labels=_lowercase)
								self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.type_sequence_label_size))

								# test greyscale images
								A_       		=   1
								A_       		=   EfficientFormerForImageClassification(_lowercase)
								model.to(_lowercase)
								model.eval()

								A_       		=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
								A_       		=   model(_lowercase)
								self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.type_sequence_label_size))



					def 						__snake_case	(  self    :	List[str])						->       int:
								A_       		=   self.prepare_config_and_inputs()
								(
								    (
								    A_
								)		,   (
								    A_
								)		,   (
								    A_
								)		,   
								)       		=   config_and_inputs
								A_       		=   {'pixel_values': pixel_values}
								return config, inputs_dict





@require_torch
class      __UpperCAmelCase							(    lowerCAmelCase ,lowerCAmelCase ,unittest.TestCase							):



					'''simple docstring'''





					_UpperCamelCase  	=		(
					    (
					        EfficientFormerModel,
					        EfficientFormerForImageClassificationWithTeacher,
					        EfficientFormerForImageClassification,
					    )
					    if is_torch_available()
					    else ()
					)
					_UpperCamelCase  	=		(
					    {
					        """feature-extraction""": EfficientFormerModel,
					        """image-classification""": (
					            EfficientFormerForImageClassification,
					            EfficientFormerForImageClassificationWithTeacher,
					        ),
					    }
					    if is_torch_available()
					    else {}
					)
					_UpperCamelCase  	=		False

					_UpperCamelCase  	=		False
					_UpperCamelCase  	=		False
					_UpperCamelCase  	=		False



					def 						__snake_case	(  self    :	Tuple)						->       int:
								A_       		=   EfficientFormerModelTester(self)
								A_       		=   ConfigTester(
								    self			,					config_class=_lowercase			,					has_text_modality=_lowercase			,					hidden_size=37)



					def 						__snake_case	(  self    :	Optional[int])						->       Any:
								self.config_tester.run_common_tests()



					@unittest.skip(reason='EfficientFormer does not use inputs_embeds')
					def 						__snake_case	(  self    :	Dict)						->       List[str]:
								pass



					@unittest.skip(reason='EfficientFormer does not support input and output embeddings')
					def 						__snake_case	(  self    :	int)						->       Optional[Any]:
								pass



					def 						__snake_case	(  self    :	Any)						->       Tuple:
								A_		,   A_       		=   self.model_tester.prepare_config_and_inputs_for_common()

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

											A_       		=   ['pixel_values']
											self.assertListEqual(arg_names[:1]			,					_lowercase)



					def 						__snake_case	(  self    :	Tuple)						->       Optional[Any]:
								def check_hidden_states_output(_lowercase    :	int			,					_lowercase    :	Union[str, Any]			,					_lowercase    :	Optional[int]):
											A_       		=   model_class(_lowercase)
											model.to(_lowercase)
											model.eval()

											with torch.no_grad():
														A_       		=   model(**self._prepare_for_class(_lowercase			,					_lowercase))

											A_       		=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

											A_       		=   getattr(
											    self.model_tester			,					'expected_num_hidden_layers'			,					self.model_tester.num_hidden_layers + 1)
											self.assertEqual(len(_lowercase)			,					_lowercase)

											if hasattr(self.model_tester			,					'encoder_seq_length'):
														A_       		=   self.model_tester.encoder_seq_length
														if hasattr(self.model_tester			,					'chunk_length') and self.model_tester.chunk_length > 1:
																	A_       		=   seq_length * self.model_tester.chunk_length
											else:
														A_       		=   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:
														A_       		=   outputs.decoder_hidden_states

														self.assertIsInstance(_lowercase			,					(list, tuple))
														self.assertEqual(len(_lowercase)			,					_lowercase)
														A_       		=   getattr(self.model_tester			,					'seq_length'			,					_lowercase)
														A_       		=   getattr(self.model_tester			,					'decoder_seq_length'			,					_lowercase)

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

								A_		,   A_       		=   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A_       		=   True
											check_hidden_states_output(_lowercase			,					_lowercase			,					_lowercase)

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

											check_hidden_states_output(_lowercase			,					_lowercase			,					_lowercase)



					def 						__snake_case	(  self    :	str			,					_lowercase    :	Optional[Any]			,					_lowercase    :	Dict			,					_lowercase    :	Optional[int]=False)						->       Union[str, Any]:
								A_       		=   super()._prepare_for_class(_lowercase			,					_lowercase			,					return_labels=_lowercase)

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

								return inputs_dict



					def 						__snake_case	(  self    :	List[str])						->       str:
								A_       		=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase)



					@unittest.skip(reason='EfficientFormer does not implement masked image modeling yet')
					def 						__snake_case	(  self    :	Dict)						->       str:
								A_       		=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*_lowercase)



					def 						__snake_case	(  self    :	Union[str, Any])						->       Optional[Any]:
								A_       		=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowercase)



					def 						__snake_case	(  self    :	int)						->       Any:
								if not self.model_tester.is_training:
											return

								A_		,   A_       		=   self.model_tester.prepare_config_and_inputs_for_common()
								A_       		=   True

								for model_class in self.all_model_classes:
											# EfficientFormerForImageClassificationWithTeacher supports inference-only
											if (
											    model_class in get_values(_lowercase)
											    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
											):
														continue
											A_       		=   model_class(_lowercase)
											model.to(_lowercase)
											model.train()
											A_       		=   self._prepare_for_class(_lowercase			,					_lowercase			,					return_labels=_lowercase)
											A_       		=   model(**_lowercase).loss
											loss.backward()



					def 						__snake_case	(  self    :	Dict)						->       Any:
								A_		,   A_       		=   self.model_tester.prepare_config_and_inputs_for_common()

								A_       		=   [
								    {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float},
								    {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long},
								    {'title': 'regression', 'num_labels': 1, 'dtype': torch.float},
								]

								for model_class in self.all_model_classes:
											if (
											    model_class
											    not in [
											        *get_values(_lowercase),
											    ]
											    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
											):
														continue

											for problem_type in problem_types:
														with self.subTest(msg=F'Testing {model_class} with {problem_type["title"]}'):
																	A_       		=   problem_type['title']
																	A_       		=   problem_type['num_labels']

																	A_       		=   model_class(_lowercase)
																	model.to(_lowercase)
																	model.train()

																	A_       		=   self._prepare_for_class(_lowercase			,					_lowercase			,					return_labels=_lowercase)

																	if problem_type["num_labels"] > 1:
																				A_       		=   inputs['labels'].unsqueeze(1).repeat(1			,					problem_type['num_labels'])

																	A_       		=   inputs['labels'].to(problem_type['dtype'])

																	# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																	# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																	# they have the same size." which is a symptom something in wrong for the regression problem.
																	# See https://github.com/huggingface/transformers/issues/11780
																	with warnings.catch_warnings(record=_lowercase) as warning_list:
																				A_       		=   model(**_lowercase).loss
																	for w in warning_list:
																				if "Using a target size that is different to the input size" in str(w.message):
																							raise ValueError(
																							    F'Something is going wrong in the regression problem: intercepted {w.message}')

																	loss.backward()



					@slow
					def 						__snake_case	(  self    :	str)						->       int:
								for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A_       		=   EfficientFormerModel.from_pretrained(_lowercase)
											self.assertIsNotNone(_lowercase)



					def 						__snake_case	(  self    :	int)						->       Tuple:
								A_		,   A_       		=   self.model_tester.prepare_config_and_inputs_for_common()
								A_       		=   True

								A_       		=   getattr(self.model_tester			,					'seq_length'			,					_lowercase)
								A_       		=   getattr(self.model_tester			,					'encoder_seq_length'			,					_lowercase)
								A_       		=   getattr(self.model_tester			,					'key_length'			,					_lowercase)
								A_       		=   getattr(self.model_tester			,					'chunk_length'			,					_lowercase)

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

								for model_class in self.all_model_classes:
											A_       		=   True
											A_       		=   False
											A_       		=   True
											A_       		=   model_class(_lowercase)
											model.to(_lowercase)
											model.eval()
											with torch.no_grad():
														A_       		=   model(**self._prepare_for_class(_lowercase			,					_lowercase))
											A_       		=   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
											self.assertEqual(len(_lowercase)			,					self.model_tester.num_attention_outputs)

											# check that output_attentions also work using config
											del inputs_dict["output_attentions"]
											A_       		=   True
											A_       		=   model_class(_lowercase)
											model.to(_lowercase)
											model.eval()
											with torch.no_grad():
														A_       		=   model(**self._prepare_for_class(_lowercase			,					_lowercase))
											A_       		=   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
											self.assertEqual(len(_lowercase)			,					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  lowerCamelCase(       )		->		List[Any]:
			A_       		=   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
			return image






@require_torch
@require_vision
class      __UpperCAmelCase							(    unittest.TestCase							):



					'''simple docstring'''





					@cached_property
					def 						__snake_case	(  self    :	Union[str, Any])						->       Any:
								return (
								    EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300')
								    if is_vision_available()
								    else None
								)



					@slow
					def 						__snake_case	(  self    :	Optional[int])						->       List[str]:
								A_       		=   EfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300').to(
								    _lowercase)

								A_       		=   self.default_image_processor
								A_       		=   prepare_img()
								A_       		=   image_processor(images=_lowercase			,					return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_       		=   model(**_lowercase)

								# verify the logits
								A_       		=   (1, 1_000)
								self.assertEqual(outputs.logits.shape			,					_lowercase)

								A_       		=   torch.tensor([-0.05_55, 0.48_25, -0.08_52]).to(_lowercase)
								self.assertTrue(torch.allclose(outputs.logits[0][:3]			,					_lowercase			,					atol=1E-4))



					@slow
					def 						__snake_case	(  self    :	Optional[Any])						->       Any:
								A_       		=   EfficientFormerForImageClassificationWithTeacher.from_pretrained(
								    'snap-research/efficientformer-l1-300').to(_lowercase)

								A_       		=   self.default_image_processor
								A_       		=   prepare_img()
								A_       		=   image_processor(images=_lowercase			,					return_tensors='pt').to(_lowercase)

								# forward pass
								with torch.no_grad():
											A_       		=   model(**_lowercase)

								# verify the logits
								A_       		=   (1, 1_000)
								self.assertEqual(outputs.logits.shape			,					_lowercase)

								A_       		=   torch.tensor([-0.13_12, 0.43_53, -1.04_99]).to(_lowercase)
								self.assertTrue(torch.allclose(outputs.logits[0][:3]			,					_lowercase			,					atol=1E-4))




