






"""simple docstring"""



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()




class        __lowercase(       unittest.TestCase  ):






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




											"""simple docstring"""





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






						@property
						def 		lowerCAmelCase   (					self)			->  Tuple:




											"""simple docstring"""





											lowerCamelCase__				=1
											lowerCamelCase__				=3
											lowerCamelCase__				=(32, 32)

											lowerCamelCase__				=floats_tensor((batch_size, num_channels) + sizes    ,						rng=random.Random(0)).to(_SCREAMING_SNAKE_CASE)
											return image






						@property
						def 		lowerCAmelCase   (					self)			->  int:




											"""simple docstring"""





											torch.manual_seed(0)
											lowerCamelCase__				=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    ,						)
											return model






						@property
						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											torch.manual_seed(0)
											lowerCamelCase__				=AutoencoderKL(
											    block_out_channels=[32, 64]    ,						in_channels=3    ,						out_channels=3    ,						down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']    ,						up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']    ,						latent_channels=4    ,						)
											return model






						@property
						def 		lowerCAmelCase   (					self)			->  List[Any]:




											"""simple docstring"""





											torch.manual_seed(0)
											lowerCamelCase__				=CLIPTextConfig(
											    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=10_00    ,						)
											return CLIPTextModel(_SCREAMING_SNAKE_CASE)






						@property
						def 		lowerCAmelCase   (					self)			->  Optional[int]:




											"""simple docstring"""





											def extract(*_SCREAMING_SNAKE_CASE    ,						**_SCREAMING_SNAKE_CASE):




																class        __lowercase:






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




																											"""simple docstring"""





																											lowerCamelCase__				=torch.ones([0])






																						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE)			->  Any:




																											"""simple docstring"""





																											self.pixel_values.to(_SCREAMING_SNAKE_CASE)
																											return self



																return Out()

											return extract






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




											"""simple docstring"""





											lowerCamelCase__				='''cpu'''  # ensure determinism for the device-dependent torch.Generator
											lowerCamelCase__				=self.dummy_cond_unet
											lowerCamelCase__				=DDIMScheduler(
											    beta_start=0.00085    ,						beta_end=0.012    ,						beta_schedule='scaled_linear'    ,						clip_sample=_SCREAMING_SNAKE_CASE    ,						set_alpha_to_one=_SCREAMING_SNAKE_CASE    ,						)

											lowerCamelCase__				=self.dummy_vae
											lowerCamelCase__				=self.dummy_text_encoder
											lowerCamelCase__				=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

											# make sure here that pndm scheduler skips prk
											lowerCamelCase__				=StableDiffusionPipeline(
											    unet=_SCREAMING_SNAKE_CASE    ,						scheduler=_SCREAMING_SNAKE_CASE    ,						vae=_SCREAMING_SNAKE_CASE    ,						text_encoder=_SCREAMING_SNAKE_CASE    ,						tokenizer=_SCREAMING_SNAKE_CASE    ,						safety_checker=_SCREAMING_SNAKE_CASE    ,						feature_extractor=self.dummy_extractor    ,						)
											lowerCamelCase__				=sd_pipe.to(_SCREAMING_SNAKE_CASE)
											sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''A painting of a squirrel eating a burger'''

											lowerCamelCase__				=torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
											lowerCamelCase__				=sd_pipe([prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=6.0    ,						num_inference_steps=2    ,						output_type='np')
											lowerCamelCase__				=output.images

											lowerCamelCase__				=torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
											lowerCamelCase__				=sd_pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=6.0    ,						num_inference_steps=2    ,						output_type='np'    ,						return_dict=_SCREAMING_SNAKE_CASE    ,						)[0]

											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											lowerCamelCase__				=np.array([0.5753, 0.6114, 0.5001, 0.5034, 0.5470, 0.4729, 0.4971, 0.4867, 0.4867])

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
											assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2






						def 		lowerCAmelCase   (					self)			->  int:




											"""simple docstring"""





											lowerCamelCase__				='''cpu'''  # ensure determinism for the device-dependent torch.Generator
											lowerCamelCase__				=self.dummy_cond_unet
											lowerCamelCase__				=PNDMScheduler(skip_prk_steps=_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=self.dummy_vae
											lowerCamelCase__				=self.dummy_text_encoder
											lowerCamelCase__				=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

											# make sure here that pndm scheduler skips prk
											lowerCamelCase__				=StableDiffusionPipeline(
											    unet=_SCREAMING_SNAKE_CASE    ,						scheduler=_SCREAMING_SNAKE_CASE    ,						vae=_SCREAMING_SNAKE_CASE    ,						text_encoder=_SCREAMING_SNAKE_CASE    ,						tokenizer=_SCREAMING_SNAKE_CASE    ,						safety_checker=_SCREAMING_SNAKE_CASE    ,						feature_extractor=self.dummy_extractor    ,						)
											lowerCamelCase__				=sd_pipe.to(_SCREAMING_SNAKE_CASE)
											sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''A painting of a squirrel eating a burger'''
											lowerCamelCase__				=torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
											lowerCamelCase__				=sd_pipe([prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=6.0    ,						num_inference_steps=2    ,						output_type='np')

											lowerCamelCase__				=output.images

											lowerCamelCase__				=torch.Generator(device=_SCREAMING_SNAKE_CASE).manual_seed(0)
											lowerCamelCase__				=sd_pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=6.0    ,						num_inference_steps=2    ,						output_type='np'    ,						return_dict=_SCREAMING_SNAKE_CASE    ,						)[0]

											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											lowerCamelCase__				=np.array([0.5122, 0.5712, 0.4825, 0.5053, 0.5646, 0.4769, 0.5179, 0.4894, 0.4994])

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
											assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2






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




											"""simple docstring"""





											lowerCamelCase__				=StableDiffusionPipeline.from_pretrained(
											    'hf-internal-testing/tiny-stable-diffusion-lms-pipe'    ,						safety_checker=_SCREAMING_SNAKE_CASE)
											assert isinstance(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)
											assert isinstance(pipe.scheduler    ,						_SCREAMING_SNAKE_CASE)
											assert pipe.safety_checker is None

											lowerCamelCase__				=pipe('example prompt'    ,						num_inference_steps=2).images[0]
											assert image is not None

											# check that there's no error when saving a pipeline with one of the models being None
											with tempfile.TemporaryDirectory() as tmpdirname:
																pipe.save_pretrained(_SCREAMING_SNAKE_CASE)
																lowerCamelCase__				=StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE)

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											lowerCamelCase__				=pipe('example prompt'    ,						num_inference_steps=2).images[0]
											assert image is not None






						@unittest.skipIf(torch_device != 'cuda'    ,						'This test requires a GPU')
						def 		lowerCAmelCase   (					self)			->  Union[str, Any]:




											"""simple docstring"""





											lowerCamelCase__				=self.dummy_cond_unet
											lowerCamelCase__				=PNDMScheduler(skip_prk_steps=_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=self.dummy_vae
											lowerCamelCase__				=self.dummy_text_encoder
											lowerCamelCase__				=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

											# put models in fp16
											lowerCamelCase__				=unet.half()
											lowerCamelCase__				=vae.half()
											lowerCamelCase__				=bert.half()

											# make sure here that pndm scheduler skips prk
											lowerCamelCase__				=StableDiffusionPipeline(
											    unet=_SCREAMING_SNAKE_CASE    ,						scheduler=_SCREAMING_SNAKE_CASE    ,						vae=_SCREAMING_SNAKE_CASE    ,						text_encoder=_SCREAMING_SNAKE_CASE    ,						tokenizer=_SCREAMING_SNAKE_CASE    ,						safety_checker=_SCREAMING_SNAKE_CASE    ,						feature_extractor=self.dummy_extractor    ,						)
											lowerCamelCase__				=sd_pipe.to(_SCREAMING_SNAKE_CASE)
											sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''A painting of a squirrel eating a burger'''
											lowerCamelCase__				=sd_pipe([prompt]    ,						num_inference_steps=2    ,						output_type='np').images

											assert image.shape == (1, 64, 64, 3)




@nightly
@require_torch_gpu
class        __lowercase(       unittest.TestCase  ):






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





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






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




											"""simple docstring"""





											lowerCamelCase__				='''cuda'''
											lowerCamelCase__				=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5')
											lowerCamelCase__				=pipe.to(_SCREAMING_SNAKE_CASE)
											pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''a photo of a cat'''
											lowerCamelCase__				={
											    '''editing_prompt''': ['''sunglasses'''],
											    '''reverse_editing_direction''': [False],
											    '''edit_warmup_steps''': 10,
											    '''edit_guidance_scale''': 6,
											    '''edit_threshold''': 0.95,
											    '''edit_momentum_scale''': 0.5,
											    '''edit_mom_beta''': 0.6,
											}

											lowerCamelCase__				=3
											lowerCamelCase__				=7

											# no sega enabled
											lowerCamelCase__				=torch.Generator(_SCREAMING_SNAKE_CASE)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.34673113,
											    0.38492733,
											    0.37597352,
											    0.34086335,
											    0.35650748,
											    0.35579205,
											    0.3384763,
											    0.34340236,
											    0.3573271,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

											# with sega enabled
											# generator = torch.manual_seed(seed)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						**_SCREAMING_SNAKE_CASE    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.41887826,
											    0.37728766,
											    0.30138272,
											    0.41416335,
											    0.41664985,
											    0.36283392,
											    0.36191246,
											    0.43364465,
											    0.43001732,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2






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




											"""simple docstring"""





											lowerCamelCase__				='''cuda'''
											lowerCamelCase__				=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5')
											lowerCamelCase__				=pipe.to(_SCREAMING_SNAKE_CASE)
											pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''an image of a crowded boulevard, realistic, 4k'''
											lowerCamelCase__				={
											    '''editing_prompt''': '''crowd, crowded, people''',
											    '''reverse_editing_direction''': True,
											    '''edit_warmup_steps''': 10,
											    '''edit_guidance_scale''': 8.3,
											    '''edit_threshold''': 0.9,
											    '''edit_momentum_scale''': 0.5,
											    '''edit_mom_beta''': 0.6,
											}

											lowerCamelCase__				=9
											lowerCamelCase__				=7

											# no sega enabled
											lowerCamelCase__				=torch.Generator(_SCREAMING_SNAKE_CASE)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.43497998,
											    0.91814065,
											    0.7540739,
											    0.55580205,
											    0.8467265,
											    0.5389691,
											    0.62574506,
											    0.58897763,
											    0.50926757,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

											# with sega enabled
											# generator = torch.manual_seed(seed)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						**_SCREAMING_SNAKE_CASE    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.3089719,
											    0.30500144,
											    0.29016042,
											    0.30630964,
											    0.325687,
											    0.29419225,
											    0.2908091,
											    0.28723598,
											    0.27696294,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2






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




											"""simple docstring"""





											lowerCamelCase__				='''cuda'''
											lowerCamelCase__				=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5')
											lowerCamelCase__				=pipe.to(_SCREAMING_SNAKE_CASE)
											pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''a castle next to a river'''
											lowerCamelCase__				={
											    '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
											    '''reverse_editing_direction''': False,
											    '''edit_warmup_steps''': [15, 18],
											    '''edit_guidance_scale''': 6,
											    '''edit_threshold''': [0.9, 0.8],
											    '''edit_momentum_scale''': 0.5,
											    '''edit_mom_beta''': 0.6,
											}

											lowerCamelCase__				=48
											lowerCamelCase__				=7

											# no sega enabled
											lowerCamelCase__				=torch.Generator(_SCREAMING_SNAKE_CASE)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.75163555,
											    0.76037145,
											    0.61785,
											    0.9189673,
											    0.8627701,
											    0.85189694,
											    0.8512813,
											    0.87012076,
											    0.8312857,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

											# with sega enabled
											# generator = torch.manual_seed(seed)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						**_SCREAMING_SNAKE_CASE    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.73553365,
											    0.7537271,
											    0.74341905,
											    0.66480356,
											    0.6472925,
											    0.63039416,
											    0.64812905,
											    0.6749717,
											    0.6517102,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2






						def 		lowerCAmelCase   (					self)			->  int:




											"""simple docstring"""





											lowerCamelCase__				='''cuda'''
											lowerCamelCase__				=StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'    ,						torch_dtype=torch.floataa)
											lowerCamelCase__				=pipe.to(_SCREAMING_SNAKE_CASE)
											pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				='''a photo of a cat'''
											lowerCamelCase__				={
											    '''editing_prompt''': ['''sunglasses'''],
											    '''reverse_editing_direction''': [False],
											    '''edit_warmup_steps''': 10,
											    '''edit_guidance_scale''': 6,
											    '''edit_threshold''': 0.95,
											    '''edit_momentum_scale''': 0.5,
											    '''edit_mom_beta''': 0.6,
											}

											lowerCamelCase__				=3
											lowerCamelCase__				=7

											# no sega enabled
											lowerCamelCase__				=torch.Generator(_SCREAMING_SNAKE_CASE)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.34887695,
											    0.3876953,
											    0.375,
											    0.34423828,
											    0.3581543,
											    0.35717773,
											    0.3383789,
											    0.34570312,
											    0.359375,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2

											# with sega enabled
											# generator = torch.manual_seed(seed)
											generator.manual_seed(_SCREAMING_SNAKE_CASE)
											lowerCamelCase__				=pipe(
											    [prompt]    ,						generator=_SCREAMING_SNAKE_CASE    ,						guidance_scale=_SCREAMING_SNAKE_CASE    ,						num_inference_steps=50    ,						output_type='np'    ,						width=5_12    ,						height=5_12    ,						**_SCREAMING_SNAKE_CASE    ,						)

											lowerCamelCase__				=output.images
											lowerCamelCase__				=image[0, -3:, -3:, -1]
											lowerCamelCase__				=[
											    0.42285156,
											    0.36914062,
											    0.29077148,
											    0.42041016,
											    0.41918945,
											    0.35498047,
											    0.3618164,
											    0.4423828,
											    0.43115234,
											]

											assert image.shape == (1, 5_12, 5_12, 3)

											assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2







"""simple docstring"""



import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VivitConfig
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


if is_torch_available():
						import torch
						from torch import nn

						from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VivitForVideoClassification, VivitModel
						from transformers.models.vivit.modeling_vivit import VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from transformers import VivitImageProcessor




class        __lowercase:






						def __init__(					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE=2    ,						_SCREAMING_SNAKE_CASE=True    ,						_SCREAMING_SNAKE_CASE=True    ,						_SCREAMING_SNAKE_CASE=10    ,						_SCREAMING_SNAKE_CASE=10    ,						_SCREAMING_SNAKE_CASE=8    ,						_SCREAMING_SNAKE_CASE=[2, 4, 4]    ,						_SCREAMING_SNAKE_CASE=3    ,						_SCREAMING_SNAKE_CASE=7_68    ,						_SCREAMING_SNAKE_CASE=5    ,						_SCREAMING_SNAKE_CASE=4    ,						_SCREAMING_SNAKE_CASE=37    ,						_SCREAMING_SNAKE_CASE="gelu_fast"    ,						_SCREAMING_SNAKE_CASE=0.0    ,						_SCREAMING_SNAKE_CASE=0.0    ,						_SCREAMING_SNAKE_CASE=0.02    ,						_SCREAMING_SNAKE_CASE=1E-06    ,						_SCREAMING_SNAKE_CASE=True    ,						_SCREAMING_SNAKE_CASE=None    ,						)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				=parent
											lowerCamelCase__				=batch_size
											lowerCamelCase__				=is_training
											lowerCamelCase__				=use_labels
											lowerCamelCase__				=num_labels
											lowerCamelCase__				=image_size
											lowerCamelCase__				=num_frames
											lowerCamelCase__				=tubelet_size
											lowerCamelCase__				=num_channels
											lowerCamelCase__				=hidden_size
											lowerCamelCase__				=num_hidden_layers
											lowerCamelCase__				=num_attention_heads
											lowerCamelCase__				=intermediate_size
											lowerCamelCase__				=hidden_act
											lowerCamelCase__				=hidden_dropout_prob
											lowerCamelCase__				=attention_probs_dropout_prob
											lowerCamelCase__				=initializer_range
											lowerCamelCase__				=layer_norm_eps
											lowerCamelCase__				=qkv_bias
											lowerCamelCase__				=scope

											lowerCamelCase__				=(
											    (self.image_size // self.tubelet_size[2])
											    * (self.image_size // self.tubelet_size[1])
											    * (self.num_frames // self.tubelet_size[0])
											) + 1  # CLS token






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




											"""simple docstring"""





											lowerCamelCase__				=floats_tensor(
											    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

											lowerCamelCase__				=None
											if self.use_labels:
																lowerCamelCase__				=ids_tensor([self.batch_size]    ,						self.num_labels)

											lowerCamelCase__				=self.get_config()

											return config, pixel_values, labels






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				=VivitConfig(
											    num_frames=self.num_frames    ,						image_size=self.image_size    ,						tubelet_size=self.tubelet_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    ,						initializer_range=self.initializer_range    ,						layer_norm_eps=self.layer_norm_eps    ,						qkv_bias=self.qkv_bias    ,						)
											lowerCamelCase__				=self.num_labels
											return config






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)			->  int:




											"""simple docstring"""





											lowerCamelCase__				=VivitModel(config=_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()
											lowerCamelCase__				=model(_SCREAMING_SNAKE_CASE)
											self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size))






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)			->  str:




											"""simple docstring"""





											lowerCamelCase__				=VivitForVideoClassification(_SCREAMING_SNAKE_CASE)
											model.to(_SCREAMING_SNAKE_CASE)
											model.eval()

											lowerCamelCase__				=model(_SCREAMING_SNAKE_CASE)

											# verify the logits shape
											lowerCamelCase__				=torch.Size((self.batch_size, self.num_labels))
											self.parent.assertEqual(result.logits.shape    ,						_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				=self.prepare_config_and_inputs()
											lowerCamelCase__				,     lowerCamelCase__				,     lowerCamelCase__				=config_and_inputs
											lowerCamelCase__				={'pixel_values': pixel_values}
											return config, inputs_dict




@require_torch
class        __lowercase(       _UpperCamelCase						,							unittest.TestCase  ):
						lowerCAmelCase_		:							str=       (VivitModel, VivitForVideoClassification) if is_torch_available() else ()

						lowerCAmelCase_		:							str=       False
						lowerCAmelCase_		:							Tuple=       False
						lowerCAmelCase_		:							Union[str, Any]=       False
						lowerCAmelCase_		:							Dict=       False






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




											"""simple docstring"""





											lowerCamelCase__				=VivitModelTester(self)
											lowerCamelCase__				=ConfigTester(self    ,						config_class=_SCREAMING_SNAKE_CASE    ,						has_text_modality=_SCREAMING_SNAKE_CASE    ,						hidden_size=37)






						def 		lowerCAmelCase   (					self    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE=False)			->  Optional[int]:




											"""simple docstring"""





											lowerCamelCase__				=copy.deepcopy(_SCREAMING_SNAKE_CASE)

											if return_labels:
																if model_class in get_values(_SCREAMING_SNAKE_CASE):
																					lowerCamelCase__				=torch.zeros(
																					    self.model_tester.batch_size    ,						dtype=torch.long    ,						device=_SCREAMING_SNAKE_CASE)

											return inputs_dict






						def 		lowerCAmelCase   (					self)			->  Tuple:




											"""simple docstring"""





											self.config_tester.run_common_tests()






						@unittest.skip(reason='Vivit does not use inputs_embeds')
						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											pass






						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											lowerCamelCase__				,     lowerCamelCase__				=self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																lowerCamelCase__				=model_class(_SCREAMING_SNAKE_CASE)
																self.assertIsInstance(model.get_input_embeddings()    ,						(nn.Module))
																lowerCamelCase__				=model.get_output_embeddings()
																self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE    ,						nn.Linear))






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											lowerCamelCase__				,     lowerCamelCase__				=self.model_tester.prepare_config_and_inputs_for_common()

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

																lowerCamelCase__				=['pixel_values', 'head_mask']
																self.assertListEqual(arg_names[:2]    ,						_SCREAMING_SNAKE_CASE)






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




											"""simple docstring"""





											lowerCamelCase__				=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE)






						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											lowerCamelCase__				=self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_video_classification(*_SCREAMING_SNAKE_CASE)






						@slow
						def 		lowerCAmelCase   (					self)			->  Tuple:




											"""simple docstring"""





											for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowerCamelCase__				=VivitModel.from_pretrained(_SCREAMING_SNAKE_CASE)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE)






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




											"""simple docstring"""





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

											for model_class in self.all_model_classes:
																lowerCamelCase__				=self.model_tester.seq_length

																lowerCamelCase__				=True
																lowerCamelCase__				=False
																lowerCamelCase__				=True
																lowerCamelCase__				=model_class(_SCREAMING_SNAKE_CASE)
																model.to(_SCREAMING_SNAKE_CASE)
																model.eval()
																with torch.no_grad():
																					lowerCamelCase__				=model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE))
																lowerCamelCase__				=outputs.attentions
																self.assertEqual(len(_SCREAMING_SNAKE_CASE)    ,						self.model_tester.num_hidden_layers)

																# check that output_attentions also work using config
																del inputs_dict["output_attentions"]
																lowerCamelCase__				=True
																lowerCamelCase__				=model_class(_SCREAMING_SNAKE_CASE)
																model.to(_SCREAMING_SNAKE_CASE)
																model.eval()
																with torch.no_grad():
																					lowerCamelCase__				=model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE))
																lowerCamelCase__				=outputs.attentions
																self.assertEqual(len(_SCREAMING_SNAKE_CASE)    ,						self.model_tester.num_hidden_layers)

																self.assertListEqual(
																    list(attentions[0].shape[-3:])    ,						[self.model_tester.num_attention_heads, seq_len, seq_len]    ,						)
																lowerCamelCase__				=len(_SCREAMING_SNAKE_CASE)

																# Check attention is always last and order is fine
																lowerCamelCase__				=True
																lowerCamelCase__				=True
																lowerCamelCase__				=model_class(_SCREAMING_SNAKE_CASE)
																model.to(_SCREAMING_SNAKE_CASE)
																model.eval()
																with torch.no_grad():
																					lowerCamelCase__				=model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE))

																self.assertEqual(out_len + 1    ,						len(_SCREAMING_SNAKE_CASE))

																lowerCamelCase__				=outputs.attentions

																self.assertEqual(len(_SCREAMING_SNAKE_CASE)    ,						self.model_tester.num_hidden_layers)

																self.assertListEqual(
																    list(self_attentions[0].shape[-3:])    ,						[self.model_tester.num_attention_heads, seq_len, seq_len]    ,						)






						def 		lowerCAmelCase   (					self)			->  Dict:




											"""simple docstring"""





											def check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE):
																lowerCamelCase__				=model_class(_SCREAMING_SNAKE_CASE)
																model.to(_SCREAMING_SNAKE_CASE)
																model.eval()

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

																lowerCamelCase__				=outputs.hidden_states
																lowerCamelCase__				=self.model_tester.num_hidden_layers + 1
																self.assertEqual(len(_SCREAMING_SNAKE_CASE)    ,						_SCREAMING_SNAKE_CASE)

																lowerCamelCase__				=self.model_tester.seq_length

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

											lowerCamelCase__				,     lowerCamelCase__				=self.model_tester.prepare_config_and_inputs_for_common()

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

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

																check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE)






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




											"""simple docstring"""





											pass




def 						lowerCamelCase_				(  ):
					lowerCamelCase__				=hf_hub_download(
					    repo_id='hf-internal-testing/spaghetti-video'			,	filename='eating_spaghetti_32_frames.npy'			,	repo_type='dataset'			)
					lowerCamelCase__				=np.load(__A			)
					return list(__A			)




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






						@cached_property
						def 		lowerCAmelCase   (					self)			->  Union[str, Any]:




											"""simple docstring"""





											return VivitImageProcessor() if is_vision_available() else None






						@slow
						def 		lowerCAmelCase   (					self)			->  str:




											"""simple docstring"""





											lowerCamelCase__				=VivitForVideoClassification.from_pretrained('google/vivit-b-16x2-kinetics400').to(_SCREAMING_SNAKE_CASE)

											lowerCamelCase__				=self.default_image_processor
											lowerCamelCase__				=prepare_video()
											lowerCamelCase__				=image_processor(_SCREAMING_SNAKE_CASE    ,						return_tensors='pt').to(_SCREAMING_SNAKE_CASE)

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

											# verify the logits
											lowerCamelCase__				=torch.Size((1, 4_00))
											self.assertEqual(outputs.logits.shape    ,						_SCREAMING_SNAKE_CASE)

											# taken from original model
											lowerCamelCase__				=torch.tensor([-1.0543, 2.0764, -0.2104, 0.4439, -0.9658]).to(_SCREAMING_SNAKE_CASE)

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