
'''simple docstring'''
import gc
import unittest

import numpy as np
import torch
import torch.nn.functional as F
from transformers import (
    ClapTextConfig,
    ClapTextModelWithProjection,
    RobertaTokenizer,
    SpeechTaHifiGan,
    SpeechTaHifiGanConfig,
)

from diffusers import (
    AudioLDMPipeline,
    AutoencoderKL,
    DDIMScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_AUDIO_BATCH_PARAMS, TEXT_TO_AUDIO_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class 			SCREAMING_SNAKE_CASE__      (     snake_case_							,       unittest.TestCase):
				lowerCAmelCase_     			=							AudioLDMPipeline
				lowerCAmelCase_     			=							TEXT_TO_AUDIO_PARAMS
				lowerCAmelCase_     			=							TEXT_TO_AUDIO_BATCH_PARAMS
				lowerCAmelCase_     			=							frozenset(
				    [
				        """num_inference_steps""",
				        """num_waveforms_per_prompt""",
				        """generator""",
				        """latents""",
				        """output_type""",
				        """return_dict""",
				        """callback""",
				        """callback_steps""",
				    ])







				def 						UpperCAmelCase_    (       self     )->		Tuple:







											'''simple docstring'''






											torch.manual_seed(0     )
											UpperCamelCase   			=     UNetaDConditionModel(
											    block_out_channels=(32, 64)						,				layers_per_block=2						,				sample_size=32						,				in_channels=4						,				out_channels=4						,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')						,				up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')						,				cross_attention_dim=(32, 64)						,				class_embed_type='simple_projection'						,				projection_class_embeddings_input_dim=32						,				class_embeddings_concat=A_						,				)
											UpperCamelCase   			=     DDIMScheduler(
											    beta_start=0.00_085						,				beta_end=0.012						,				beta_schedule='scaled_linear'						,				clip_sample=A_						,				set_alpha_to_one=A_						,				)
											torch.manual_seed(0     )
											UpperCamelCase   			=     AutoencoderKL(
											    block_out_channels=[32, 64]						,				in_channels=1						,				out_channels=1						,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']						,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']						,				latent_channels=4						,				)
											torch.manual_seed(0     )
											UpperCamelCase   			=     ClapTextConfig(
											    bos_token_id=0						,				eos_token_id=2						,				hidden_size=32						,				intermediate_size=37						,				layer_norm_eps=1e-05						,				num_attention_heads=4						,				num_hidden_layers=5						,				pad_token_id=1						,				vocab_size=1000						,				projection_dim=32						,				)
											UpperCamelCase   			=     ClapTextModelWithProjection(A_     )
											UpperCamelCase   			=     RobertaTokenizer.from_pretrained('hf-internal-testing/tiny-random-roberta'						,				model_max_length=77     )

											UpperCamelCase   			=     SpeechTaHifiGanConfig(
											    model_in_dim=8						,				sampling_rate=16000						,				upsample_initial_channel=16						,				upsample_rates=[2, 2]						,				upsample_kernel_sizes=[4, 4]						,				resblock_kernel_sizes=[3, 7]						,				resblock_dilation_sizes=[[1, 3, 5], [1, 3, 5]]						,				normalize_before=A_						,				)

											UpperCamelCase   			=     SpeechTaHifiGan(A_     )

											UpperCamelCase   			=     {
											    'unet': unet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											    'vocoder': vocoder,
											}
											return components







				def 						UpperCAmelCase_    (       self						,				A_						,				A_=0     )->		Optional[int]:







											'''simple docstring'''






											if str(A_     ).startswith('mps'     ):
																		UpperCamelCase   			=     torch.manual_seed(A_     )
											else:
																		UpperCamelCase   			=     torch.Generator(device=A_     ).manual_seed(A_     )
											UpperCamelCase   			=     {
											    'prompt': 'A hammer hitting a wooden surface',
											    'generator': generator,
											    'num_inference_steps': 2,
											    'guidance_scale': 6.0,
											}
											return inputs







				def 						UpperCAmelCase_    (       self     )->		Dict:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'  # ensure determinism for the device-dependent torch.Generator

											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     audioldm_pipe(**A_     )
											UpperCamelCase   			=     output.audios[0]

											assert audio.ndim == 1
											assert len(A_     ) == 256

											UpperCamelCase   			=     audio[:10]
											UpperCamelCase   			=     np.array(
											    [-0.0_050, 0.0_050, -0.0_060, 0.0_033, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_033]     )

											assert np.abs(audio_slice - expected_slice     ).max() < 1e-2







				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     3 * [inputs['prompt']]

											# forward
											UpperCamelCase   			=     audioldm_pipe(**A_     )
											UpperCamelCase   			=     output.audios[0]

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     3 * [inputs.pop('prompt'     )]

											UpperCamelCase   			=     audioldm_pipe.tokenizer(
											    A_						,				padding='max_length'						,				max_length=audioldm_pipe.tokenizer.model_max_length						,				truncation=A_						,				return_tensors='pt'						,				)
											UpperCamelCase   			=     text_inputs['input_ids'].to(A_     )

											UpperCamelCase   			=     audioldm_pipe.text_encoder(
											    A_						,				)
											UpperCamelCase   			=     prompt_embeds.text_embeds
											# additional L_2 normalization over each hidden-state
											UpperCamelCase   			=     F.normalize(A_						,				dim=-1     )

											UpperCamelCase   			=     prompt_embeds

											# forward
											UpperCamelCase   			=     audioldm_pipe(**A_     )
											UpperCamelCase   			=     output.audios[0]

											assert np.abs(audio_a - audio_a     ).max() < 1e-2







				def 						UpperCAmelCase_    (       self     )->		Union[str, Any]:







											'''simple docstring'''






											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     3 * ['this is a negative prompt']
											UpperCamelCase   			=     negative_prompt
											UpperCamelCase   			=     3 * [inputs['prompt']]

											# forward
											UpperCamelCase   			=     audioldm_pipe(**A_     )
											UpperCamelCase   			=     output.audios[0]

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     3 * [inputs.pop('prompt'     )]

											UpperCamelCase   			=     []
											for p in [prompt, negative_prompt]:
																		UpperCamelCase   			=     audioldm_pipe.tokenizer(
																		    A_						,				padding='max_length'						,				max_length=audioldm_pipe.tokenizer.model_max_length						,				truncation=A_						,				return_tensors='pt'						,				)
																		UpperCamelCase   			=     text_inputs['input_ids'].to(A_     )

																		UpperCamelCase   			=     audioldm_pipe.text_encoder(
																		    A_						,				)
																		UpperCamelCase   			=     text_embeds.text_embeds
																		# additional L_2 normalization over each hidden-state
																		UpperCamelCase   			=     F.normalize(A_						,				dim=-1     )

																		embeds.append(A_     )

											UpperCamelCase			,	UpperCamelCase   			=     embeds

											# forward
											UpperCamelCase   			=     audioldm_pipe(**A_     )
											UpperCamelCase   			=     output.audios[0]

											assert np.abs(audio_a - audio_a     ).max() < 1e-2







				def 						UpperCAmelCase_    (       self     )->		int:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     PNDMScheduler(skip_prk_steps=A_     )
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     'egg cracking'
											UpperCamelCase   			=     audioldm_pipe(**A_						,				negative_prompt=A_     )
											UpperCamelCase   			=     output.audios[0]

											assert audio.ndim == 1
											assert len(A_     ) == 256

											UpperCamelCase   			=     audio[:10]
											UpperCamelCase   			=     np.array(
											    [-0.0_051, 0.0_050, -0.0_060, 0.0_034, -0.0_026, 0.0_033, -0.0_027, 0.0_033, -0.0_028, 0.0_032]     )

											assert np.abs(audio_slice - expected_slice     ).max() < 1e-2







				def 						UpperCAmelCase_    (       self     )->		int:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     PNDMScheduler(skip_prk_steps=A_     )
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     'A hammer hitting a wooden surface'

											# test num_waveforms_per_prompt=1 (default)
											UpperCamelCase   			=     audioldm_pipe(A_						,				num_inference_steps=2     ).audios

											assert audios.shape == (1, 256)

											# test num_waveforms_per_prompt=1 (default) for batch of prompts
											UpperCamelCase   			=     2
											UpperCamelCase   			=     audioldm_pipe([prompt] * batch_size						,				num_inference_steps=2     ).audios

											assert audios.shape == (batch_size, 256)

											# test num_waveforms_per_prompt for single prompt
											UpperCamelCase   			=     2
											UpperCamelCase   			=     audioldm_pipe(A_						,				num_inference_steps=2						,				num_waveforms_per_prompt=A_     ).audios

											assert audios.shape == (num_waveforms_per_prompt, 256)

											# test num_waveforms_per_prompt for batch of prompts
											UpperCamelCase   			=     2
											UpperCamelCase   			=     audioldm_pipe(
											    [prompt] * batch_size						,				num_inference_steps=2						,				num_waveforms_per_prompt=A_     ).audios

											assert audios.shape == (batch_size * num_waveforms_per_prompt, 256)







				def 						UpperCAmelCase_    (       self     )->		Any:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )
											UpperCamelCase   			=     audioldm_pipe.vocoder.config.sampling_rate

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     audioldm_pipe(audio_length_in_s=0.016						,				**A_     )
											UpperCamelCase   			=     output.audios[0]

											assert audio.ndim == 1
											assert len(A_     ) / vocoder_sampling_rate == 0.016

											UpperCamelCase   			=     audioldm_pipe(audio_length_in_s=0.032						,				**A_     )
											UpperCamelCase   			=     output.audios[0]

											assert audio.ndim == 1
											assert len(A_     ) / vocoder_sampling_rate == 0.032







				def 						UpperCAmelCase_    (       self     )->		List[str]:







											'''simple docstring'''






											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     AudioLDMPipeline(**A_     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     ['hey']

											UpperCamelCase   			=     audioldm_pipe(A_						,				num_inference_steps=1     )
											UpperCamelCase   			=     output.audios.shape
											assert audio_shape == (1, 256)

											UpperCamelCase   			=     audioldm_pipe.vocoder.config
											config.model_in_dim *= 2
											UpperCamelCase   			=     SpeechTaHifiGan(A_     ).to(A_     )
											UpperCamelCase   			=     audioldm_pipe(A_						,				num_inference_steps=1     )
											UpperCamelCase   			=     output.audios.shape
											# waveform shape is unchanged, we just have 2x the number of mel channels in the spectrogram
											assert audio_shape == (1, 256)







				def 						UpperCAmelCase_    (       self     )->		List[Any]:







											'''simple docstring'''






											self._test_attention_slicing_forward_pass(test_mean_pixel_difference=A_     )







				def 						UpperCAmelCase_    (       self     )->		Tuple:







											'''simple docstring'''






											self._test_inference_batch_single_identical(test_mean_pixel_difference=A_     )







				@unittest.skipIf(
				    torch_device != 'cuda' or not is_xformers_available()						,				reason='XFormers attention is only available with CUDA and `xformers` installed'						,				)
				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A_     )


@slow
class 			SCREAMING_SNAKE_CASE__      (     unittest.TestCase):







				def 						UpperCAmelCase_    (       self     )->		List[str]:







											'''simple docstring'''






											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()







				def 						UpperCAmelCase_    (       self						,				A_						,				A_="cpu"						,				A_=torch.floataa						,				A_=0     )->		Optional[int]:







											'''simple docstring'''






											UpperCamelCase   			=     torch.Generator(device=A_     ).manual_seed(A_     )
											UpperCamelCase   			=     np.random.RandomState(A_     ).standard_normal((1, 8, 128, 16)     )
											UpperCamelCase   			=     torch.from_numpy(A_     ).to(device=A_						,				dtype=A_     )
											UpperCamelCase   			=     {
											    'prompt': 'A hammer hitting a wooden surface',
											    'latents': latents,
											    'generator': generator,
											    'num_inference_steps': 3,
											    'guidance_scale': 2.5,
											}
											return inputs







				def 						UpperCAmelCase_    (       self     )->		Optional[int]:







											'''simple docstring'''






											UpperCamelCase   			=     AudioLDMPipeline.from_pretrained('cvssp/audioldm'     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_inputs(A_     )
											UpperCamelCase   			=     25
											UpperCamelCase   			=     audioldm_pipe(**A_     ).audios[0]

											assert audio.ndim == 1
											assert len(A_     ) == 81920

											UpperCamelCase   			=     audio[77230:77240]
											UpperCamelCase   			=     np.array(
											    [-0.4_884, -0.4_607, 0.0_023, 0.5_007, 0.5_896, 0.5_151, 0.3_813, -0.0_208, -0.3_687, -0.4_315]     )
											UpperCamelCase   			=     np.abs(expected_slice - audio_slice     ).max()
											assert max_diff < 1e-2







				def 						UpperCAmelCase_    (       self     )->		Union[str, Any]:







											'''simple docstring'''






											UpperCamelCase   			=     AudioLDMPipeline.from_pretrained('cvssp/audioldm'     )
											UpperCamelCase   			=     LMSDiscreteScheduler.from_config(audioldm_pipe.scheduler.config     )
											UpperCamelCase   			=     audioldm_pipe.to(A_     )
											audioldm_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_inputs(A_     )
											UpperCamelCase   			=     audioldm_pipe(**A_     ).audios[0]

											assert audio.ndim == 1
											assert len(A_     ) == 81920

											UpperCamelCase   			=     audio[27780:27790]
											UpperCamelCase   			=     np.array([-0.2_131, -0.0_873, -0.0_124, -0.0_189, 0.0_569, 0.1_373, 0.1_883, 0.2_886, 0.3_297, 0.2_212]     )
											UpperCamelCase   			=     np.abs(expected_slice - audio_slice     ).max()
											assert max_diff < 3e-2





import inspect
import unittest
import warnings
from math import ceil, floor

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

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,
     LevitForImageClassification,
     LevitForImageClassificationWithTeacher,
     LevitModel,
 )
 from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import LevitImageProcessor

class 					_lowercase    (     UpperCAmelCase__			):






    '''simple docstring'''




    def      _a    (    self ):
       lowerCAmelCase_:							Optional[int]       =	self.config_class(**self.inputs_dict )
       self.parent.assertTrue(hasattr(lowerCamelCase__       ,						"hidden_sizes" ) )
       self.parent.assertTrue(hasattr(lowerCamelCase__       ,						"num_attention_heads" ) )





class 					_lowercase    :






    '''simple docstring'''




    def __init__(    self       ,						lowerCamelCase__       ,						lowerCamelCase__=13       ,						lowerCamelCase__=64       ,						lowerCamelCase__=3       ,						lowerCamelCase__=3       ,						lowerCamelCase__=2       ,						lowerCamelCase__=1       ,						lowerCamelCase__=16       ,						lowerCamelCase__=[128, 256, 384]       ,						lowerCamelCase__=[4, 6, 8]       ,						lowerCamelCase__=[2, 3, 4]       ,						lowerCamelCase__=[16, 16, 16]       ,						lowerCamelCase__=0       ,						lowerCamelCase__=[2, 2, 2]       ,						lowerCamelCase__=[2, 2, 2]       ,						lowerCamelCase__=0.0_2       ,						lowerCamelCase__=True       ,						lowerCamelCase__=True       ,						lowerCamelCase__=2       ,						):
       lowerCAmelCase_:							int       =	parent
       lowerCAmelCase_:							Tuple       =	batch_size
       lowerCAmelCase_:							List[str]       =	image_size
       lowerCAmelCase_:							Tuple       =	num_channels
       lowerCAmelCase_:							Optional[int]       =	kernel_size
       lowerCAmelCase_:							int       =	stride
       lowerCAmelCase_:							Optional[int]       =	padding
       lowerCAmelCase_:							Tuple       =	hidden_sizes
       lowerCAmelCase_:							Union[str, Any]       =	num_attention_heads
       lowerCAmelCase_:							Tuple       =	depths
       lowerCAmelCase_:							Optional[int]       =	key_dim
       lowerCAmelCase_:							Optional[Any]       =	drop_path_rate
       lowerCAmelCase_:							List[str]       =	patch_size
       lowerCAmelCase_:							Any       =	attention_ratio
       lowerCAmelCase_:							Tuple       =	mlp_ratio
       lowerCAmelCase_:							Any       =	initializer_range
       lowerCAmelCase_:							List[str]       =	[
           ["Subsample", key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
           ["Subsample", key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
       ]
       lowerCAmelCase_:							Any       =	is_training
       lowerCAmelCase_:							Optional[int]       =	use_labels
       lowerCAmelCase_:							Dict       =	num_labels
       lowerCAmelCase_:							Any       =	initializer_range




    def      _a    (    self ):
       lowerCAmelCase_:							Union[str, Any]       =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

       lowerCAmelCase_:							Tuple       =	None
       if self.use_labels:
          lowerCAmelCase_:							int       =	ids_tensor([self.batch_size]       ,						self.num_labels )

       lowerCAmelCase_:							Tuple       =	self.get_config()
       return config, pixel_values, labels




    def      _a    (    self ):
       return LevitConfig(
           image_size=self.image_size       ,						num_channels=self.num_channels       ,						kernel_size=self.kernel_size       ,						stride=self.stride       ,						padding=self.padding       ,						patch_size=self.patch_size       ,						hidden_sizes=self.hidden_sizes       ,						num_attention_heads=self.num_attention_heads       ,						depths=self.depths       ,						key_dim=self.key_dim       ,						drop_path_rate=self.drop_path_rate       ,						mlp_ratio=self.mlp_ratio       ,						attention_ratio=self.attention_ratio       ,						initializer_range=self.initializer_range       ,						down_ops=self.down_ops       ,						)




    def      _a    (    self       ,						lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__ ):
       lowerCAmelCase_:							int       =	LevitModel(config=lowerCamelCase__ )
       model.to(lowerCamelCase__ )
       model.eval()
       lowerCAmelCase_:							Optional[Any]       =	model(lowerCamelCase__ )
       lowerCAmelCase_:							Tuple       =	(self.image_size, self.image_size)
       lowerCAmelCase_  ,	lowerCAmelCase_:							Optional[int]       =	image_size[0], image_size[1]
       for _ in range(4 ):
          lowerCAmelCase_:							Union[str, Any]       =	floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1 )
          lowerCAmelCase_:							str       =	floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1 )
       self.parent.assertEqual(
           result.last_hidden_state.shape       ,						(self.batch_size, ceil(height / 4 ) * ceil(width / 4 ), self.hidden_sizes[-1])       ,						)




    def      _a    (    self       ,						lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__ ):
       lowerCAmelCase_:							Tuple       =	self.num_labels
       lowerCAmelCase_:							str       =	LevitForImageClassification(lowerCamelCase__ )
       model.to(lowerCamelCase__ )
       model.eval()
       lowerCAmelCase_:							Optional[Any]       =	model(lowerCamelCase__       ,						labels=lowerCamelCase__ )
       self.parent.assertEqual(result.logits.shape       ,						(self.batch_size, self.num_labels) )




    def      _a    (    self ):
       lowerCAmelCase_:							Union[str, Any]       =	self.prepare_config_and_inputs()
       lowerCAmelCase_  ,	lowerCAmelCase_  ,	lowerCAmelCase_:							Dict       =	config_and_inputs
       lowerCAmelCase_:							Tuple       =	{"pixel_values": pixel_values}
       return config, inputs_dict





@require_torch
class 					_lowercase    (     UpperCAmelCase__ ,  UpperCAmelCase__ ,  unittest.TestCase			):






    '''simple docstring'''
    SCREAMING_SNAKE_CASE:				Any          =    (
        (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
        if is_torch_available()
        else ()
    )
    SCREAMING_SNAKE_CASE:				int          =    (
        {
            'feature-extraction': LevitModel,
            'image-classification': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
        }
        if is_torch_available()
        else {}
    )

    SCREAMING_SNAKE_CASE:				Optional[int]          =    False
    SCREAMING_SNAKE_CASE:				Optional[Any]          =    False
    SCREAMING_SNAKE_CASE:				str          =    False
    SCREAMING_SNAKE_CASE:				str          =    False
    SCREAMING_SNAKE_CASE:				List[Any]          =    False




    def      _a    (    self ):
       lowerCAmelCase_:							List[str]       =	LevitModelTester(self )
       lowerCAmelCase_:							Union[str, Any]       =	ConfigTester(self       ,						config_class=lowerCamelCase__       ,						has_text_modality=lowerCamelCase__       ,						hidden_size=37 )




    def      _a    (    self ):
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()




    def      _a    (    self ):
       return




    @unittest.skip(reason="Levit does not use inputs_embeds" )
    def      _a    (    self ):
       pass




    @unittest.skip(reason="Levit does not support input and output embeddings" )
    def      _a    (    self ):
       pass




    @unittest.skip(reason="Levit does not output attentions" )
    def      _a    (    self ):
       pass




    def      _a    (    self ):
       lowerCAmelCase_  ,	lowerCAmelCase_:							Optional[Any]       =	self.model_tester.prepare_config_and_inputs_for_common()

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

          lowerCAmelCase_:							str       =	["pixel_values"]
          self.assertListEqual(arg_names[:1]       ,						lowerCamelCase__ )




    def      _a    (    self ):
       def check_hidden_states_output(lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__ ):
          lowerCAmelCase_:							int       =	model_class(lowerCamelCase__ )
          model.to(lowerCamelCase__ )
          model.eval()

          with torch.no_grad():
             lowerCAmelCase_:							Dict       =	model(**self._prepare_for_class(lowerCamelCase__       ,						lowerCamelCase__ ) )

          lowerCAmelCase_:							str       =	outputs.hidden_states

          lowerCAmelCase_:							List[Any]       =	len(self.model_tester.depths ) + 1
          self.assertEqual(len(lowerCamelCase__ )       ,						lowerCamelCase__ )

          lowerCAmelCase_:							List[Any]       =	(self.model_tester.image_size, self.model_tester.image_size)
          lowerCAmelCase_  ,	lowerCAmelCase_:							int       =	image_size[0], image_size[1]
          for _ in range(4 ):
             lowerCAmelCase_:							Tuple       =	floor(
                 (
                     (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                     / self.model_tester.stride
                 )
                 + 1 )
             lowerCAmelCase_:							Optional[int]       =	floor(
                 (
                     (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                     / self.model_tester.stride
                 )
                 + 1 )
          # verify the first hidden states (first block)
          self.assertListEqual(
              list(hidden_states[0].shape[-2:] )       ,						[
                  height * width,
                  self.model_tester.hidden_sizes[0],
              ]       ,						)

       lowerCAmelCase_  ,	lowerCAmelCase_:							str       =	self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          lowerCAmelCase_:							int       =	True
          check_hidden_states_output(lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__ )

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          lowerCAmelCase_:							Union[str, Any]       =	True

          check_hidden_states_output(lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__ )




    @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." )
    def      _a    (    self ):
       pass




    def      _a    (    self       ,						lowerCamelCase__       ,						lowerCamelCase__       ,						lowerCamelCase__=False ):
       lowerCAmelCase_:							List[str]       =	super()._prepare_for_class(lowerCamelCase__       ,						lowerCamelCase__       ,						return_labels=lowerCamelCase__ )

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

       return inputs_dict




    def      _a    (    self ):
       lowerCAmelCase_:							Union[str, Any]       =	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowerCamelCase__ )




    def      _a    (    self ):
       lowerCAmelCase_:							str       =	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__ )




    def      _a    (    self ):
       if not self.model_tester.is_training:
          return

       lowerCAmelCase_  ,	lowerCAmelCase_:							Tuple       =	self.model_tester.prepare_config_and_inputs_for_common()
       lowerCAmelCase_:							int       =	True

       for model_class in self.all_model_classes:
          # LevitForImageClassificationWithTeacher supports inference-only
          if (
              model_class in get_values(lowerCamelCase__ )
              or model_class.__name__ == "LevitForImageClassificationWithTeacher"
          ):
             continue
          lowerCAmelCase_:							Tuple       =	model_class(lowerCamelCase__ )
          model.to(lowerCamelCase__ )
          model.train()
          lowerCAmelCase_:							Optional[int]       =	self._prepare_for_class(lowerCamelCase__       ,						lowerCamelCase__       ,						return_labels=lowerCamelCase__ )
          lowerCAmelCase_:							Tuple       =	model(**lowerCamelCase__ ).loss
          loss.backward()




    def      _a    (    self ):
       lowerCAmelCase_  ,	lowerCAmelCase_:							List[str]       =	self.model_tester.prepare_config_and_inputs_for_common()
       if not self.model_tester.is_training:
          return

       lowerCAmelCase_:							Any       =	False
       lowerCAmelCase_:							Tuple       =	True

       for model_class in self.all_model_classes:
          if model_class in get_values(lowerCamelCase__ ) or not model_class.supports_gradient_checkpointing:
             continue
          # LevitForImageClassificationWithTeacher supports inference-only
          if model_class.__name__ == "LevitForImageClassificationWithTeacher":
             continue
          lowerCAmelCase_:							Any       =	model_class(lowerCamelCase__ )
          model.gradient_checkpointing_enable()
          model.to(lowerCamelCase__ )
          model.train()
          lowerCAmelCase_:							str       =	self._prepare_for_class(lowerCamelCase__       ,						lowerCamelCase__       ,						return_labels=lowerCamelCase__ )
          lowerCAmelCase_:							List[str]       =	model(**lowerCamelCase__ ).loss
          loss.backward()




    def      _a    (    self ):
       lowerCAmelCase_  ,	lowerCAmelCase_:							int       =	self.model_tester.prepare_config_and_inputs_for_common()

       lowerCAmelCase_:							Optional[int]       =	[
           {"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(lowerCamelCase__ ),
              ]
              or model_class.__name__ == "LevitForImageClassificationWithTeacher"
          ):
             continue

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

                lowerCAmelCase_:							List[str]       =	model_class(lowerCamelCase__ )
                model.to(lowerCamelCase__ )
                model.train()

                lowerCAmelCase_:							List[Any]       =	self._prepare_for_class(lowerCamelCase__       ,						lowerCamelCase__       ,						return_labels=lowerCamelCase__ )

                if problem_type["num_labels"] > 1:
                   lowerCAmelCase_:							List[str]       =	inputs["labels"].unsqueeze(1 ).repeat(1       ,						problem_type["num_labels"] )

                lowerCAmelCase_:							List[Any]       =	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=lowerCamelCase__ ) as warning_list:
                   lowerCAmelCase_:							Dict       =	model(**lowerCamelCase__ ).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      _a    (    self ):
       for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowerCAmelCase_:							Optional[int]       =	LevitModel.from_pretrained(lowerCamelCase__ )
          self.assertIsNotNone(lowerCamelCase__ )





def 		snake_case__	(		):
   lowerCAmelCase_:							Optional[int]       =	Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
   return image







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






    '''simple docstring'''




    @cached_property
    def      _a    (    self ):
       return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] )




    @slow
    def      _a    (    self ):
       lowerCAmelCase_:							Any       =	LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(
           lowerCamelCase__ )

       lowerCAmelCase_:							str       =	self.default_image_processor
       lowerCAmelCase_:							int       =	prepare_img()
       lowerCAmelCase_:							Optional[int]       =	image_processor(images=lowerCamelCase__       ,						return_tensors="pt" ).to(lowerCamelCase__ )

       # forward pass
       with torch.no_grad():
          lowerCAmelCase_:							Tuple       =	model(**lowerCamelCase__ )

       # verify the logits
       lowerCAmelCase_:							str       =	torch.Size((1, 1_000) )
       self.assertEqual(outputs.logits.shape       ,						lowerCamelCase__ )

       lowerCAmelCase_:							Union[str, Any]       =	torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7] ).to(lowerCamelCase__ )

       self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,						lowerCamelCase__       ,						atol=1E-4 ) )