






import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class  __UpperCAmelCase						(lowerCamelCase__			,lowerCamelCase__			,unittest.TestCase       ):
			__snake_case							: Optional[int]							=				StableDiffusionParadigmsPipeline
			__snake_case							: Optional[Any]							=				TEXT_TO_IMAGE_PARAMS
			__snake_case							: Tuple							=				TEXT_TO_IMAGE_BATCH_PARAMS
			__snake_case							: Union[str, Any]							=				TEXT_TO_IMAGE_IMAGE_PARAMS
			__snake_case							: Tuple							=				TEXT_TO_IMAGE_IMAGE_PARAMS







			def 				UpperCamelCase (      self:    Optional[int]	):







									'''simple docstring'''




									torch.manual_seed(0	)
									_SCREAMING_SNAKE_CASE       =    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 ,      attention_head_dim=(2, 4) ,      use_linear_projection=_snake_case ,      )
									_SCREAMING_SNAKE_CASE       =    DDIMParallelScheduler(
									    beta_start=0.0_00_85 ,      beta_end=0.0_12 ,      beta_schedule="""scaled_linear""" ,      clip_sample=_snake_case ,      set_alpha_to_one=_snake_case ,      )
									torch.manual_seed(0	)
									_SCREAMING_SNAKE_CASE       =    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 ,      sample_size=128 ,      )
									torch.manual_seed(0	)
									_SCREAMING_SNAKE_CASE       =    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=1_000 ,      hidden_act="""gelu""" ,      projection_dim=512 ,      )
									_SCREAMING_SNAKE_CASE       =    CLIPTextModel(_snake_case	)
									_SCREAMING_SNAKE_CASE       =    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

									_SCREAMING_SNAKE_CASE       =    {
									    """unet""": unet,
									    """scheduler""": scheduler,
									    """vae""": vae,
									    """text_encoder""": text_encoder,
									    """tokenizer""": tokenizer,
									    """safety_checker""": None,
									    """feature_extractor""": None,
									}
									return components







			def 				UpperCamelCase (      self:    str ,      UpperCAmelCase_:    Any ,      UpperCAmelCase_:    List[Any]=0	):







									'''simple docstring'''




									if str(_snake_case	).startswith("""mps"""	):
															_SCREAMING_SNAKE_CASE       =    torch.manual_seed(_snake_case	)
									else:
															_SCREAMING_SNAKE_CASE       =    torch.Generator(device=_snake_case	).manual_seed(_snake_case	)
									_SCREAMING_SNAKE_CASE       =    {
									    """prompt""": """a photograph of an astronaut riding a horse""",
									    """generator""": generator,
									    """num_inference_steps""": 10,
									    """guidance_scale""": 6.0,
									    """output_type""": """numpy""",
									    """parallel""": 3,
									    """debug""": True,
									}
									return inputs







			def 				UpperCamelCase (      self:    int	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    """cpu"""  # ensure determinism for the device-dependent torch.Generator
									_SCREAMING_SNAKE_CASE       =    self.get_dummy_components()
									_SCREAMING_SNAKE_CASE       =    StableDiffusionParadigmsPipeline(**_snake_case	)
									_SCREAMING_SNAKE_CASE       =    sd_pipe.to(_snake_case	)
									sd_pipe.set_progress_bar_config(disable=_snake_case	)

									_SCREAMING_SNAKE_CASE       =    self.get_dummy_inputs(_snake_case	)
									_SCREAMING_SNAKE_CASE       =    sd_pipe(**_snake_case	).images
									_SCREAMING_SNAKE_CASE       =    image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									_SCREAMING_SNAKE_CASE       =    np.array([0.47_73, 0.54_17, 0.47_23, 0.49_25, 0.56_31, 0.47_52, 0.52_40, 0.49_35, 0.50_23]	)

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







			def 				UpperCamelCase (      self:    Optional[int]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    """cpu"""  # ensure determinism for the device-dependent torch.Generator
									_SCREAMING_SNAKE_CASE       =    self.get_dummy_components()
									torch.manual_seed(0	)
									_SCREAMING_SNAKE_CASE       =    DDPMParallelScheduler()
									torch.manual_seed(0	)
									_SCREAMING_SNAKE_CASE       =    StableDiffusionParadigmsPipeline(**_snake_case	)
									_SCREAMING_SNAKE_CASE       =    sd_pipe.to(_snake_case	)
									sd_pipe.set_progress_bar_config(disable=_snake_case	)

									_SCREAMING_SNAKE_CASE       =    self.get_dummy_inputs(_snake_case	)
									_SCREAMING_SNAKE_CASE       =    sd_pipe(**_snake_case	).images
									_SCREAMING_SNAKE_CASE       =    image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									_SCREAMING_SNAKE_CASE       =    np.array([0.35_73, 0.44_20, 0.49_60, 0.47_99, 0.37_96, 0.38_79, 0.48_19, 0.43_65, 0.44_68]	)

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







			def 				UpperCamelCase (      self:    Union[str, Any]	):







									'''simple docstring'''




									super().test_inference_batch_consistent(batch_sizes=[1, 2]	)







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									super().test_inference_batch_single_identical(batch_size=2 ,      expected_max_diff=3E-3	)







			def 				UpperCamelCase (      self:    List[str]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    """cpu"""  # ensure determinism for the device-dependent torch.Generator
									_SCREAMING_SNAKE_CASE       =    self.get_dummy_components()
									_SCREAMING_SNAKE_CASE       =    StableDiffusionParadigmsPipeline(**_snake_case	)
									_SCREAMING_SNAKE_CASE       =    sd_pipe.to(_snake_case	)
									sd_pipe.set_progress_bar_config(disable=_snake_case	)

									_SCREAMING_SNAKE_CASE       =    self.get_dummy_inputs(_snake_case	)
									_SCREAMING_SNAKE_CASE       =    """french fries"""
									_SCREAMING_SNAKE_CASE       =    sd_pipe(**_snake_case ,      negative_prompt=_snake_case	)
									_SCREAMING_SNAKE_CASE       =    output.images
									_SCREAMING_SNAKE_CASE       =    image[0, -3:, -3:, -1]

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

									_SCREAMING_SNAKE_CASE       =    np.array([0.47_71, 0.54_20, 0.46_83, 0.49_18, 0.56_36, 0.47_25, 0.52_30, 0.49_23, 0.50_15]	)

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



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







			def 				UpperCamelCase (      self:    Union[str, Any]	):







									'''simple docstring'''




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







			def 				UpperCamelCase (      self:    Optional[Any] ,      UpperCAmelCase_:    List[Any]=0	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    torch.Generator(device=_snake_case	).manual_seed(_snake_case	)
									_SCREAMING_SNAKE_CASE       =    {
									    """prompt""": """a photograph of an astronaut riding a horse""",
									    """generator""": generator,
									    """num_inference_steps""": 10,
									    """guidance_scale""": 7.5,
									    """output_type""": """numpy""",
									    """parallel""": 3,
									    """debug""": True,
									}
									return inputs







			def 				UpperCamelCase (      self:    List[Any]	):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE       =    """stabilityai/stable-diffusion-2-base"""
									_SCREAMING_SNAKE_CASE       =    DDIMParallelScheduler.from_pretrained(_snake_case ,      subfolder="""scheduler"""	)
									_SCREAMING_SNAKE_CASE       =    StableDiffusionParadigmsPipeline.from_pretrained(_snake_case ,      scheduler=_snake_case ,      safety_checker=_snake_case	)
									pipe.to(_snake_case	)
									pipe.set_progress_bar_config(disable=_snake_case	)
									pipe.enable_attention_slicing()

									_SCREAMING_SNAKE_CASE       =    self.get_inputs()
									_SCREAMING_SNAKE_CASE       =    pipe(**_snake_case	).images
									_SCREAMING_SNAKE_CASE       =    image[0, -3:, -3:, -1].flatten()

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

									_SCREAMING_SNAKE_CASE       =    np.array([0.96_22, 0.96_02, 0.97_48, 0.95_91, 0.96_30, 0.96_91, 0.96_61, 0.96_31, 0.97_41]	)

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






from ...configuration_utils import PretrainedConfig
from ...utils import logging


A__       =			logging.get_logger(__name__)

A__       =			{
    """MCG-NJU/videomae-base""": """https://huggingface.co/MCG-NJU/videomae-base/resolve/main/config.json""",
}





class    __lowerCAmelCase					(	lowerCamelCase__			):
				__lowerCamelCase					=							'''videomae'''




				def __init__(				self		,							_snake_case=224		,							_snake_case=16		,							_snake_case=3		,							_snake_case=16		,							_snake_case=2		,							_snake_case=768		,							_snake_case=12		,							_snake_case=12		,							_snake_case=3072		,							_snake_case="gelu"		,							_snake_case=0.0		,							_snake_case=0.0		,							_snake_case=0.02		,							_snake_case=1e-12		,							_snake_case=True		,							_snake_case=True		,							_snake_case=6		,							_snake_case=384		,							_snake_case=4		,							_snake_case=1536		,							_snake_case=True		,							**_snake_case		,							):



									"""simple docstring"""





									super().__init__(**_snake_case						)

									_lowerCAmelCase         =       image_size
									_lowerCAmelCase         =       patch_size
									_lowerCAmelCase         =       num_channels
									_lowerCAmelCase         =       num_frames
									_lowerCAmelCase         =       tubelet_size

									_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         =       use_mean_pooling

									_lowerCAmelCase         =       decoder_num_attention_heads
									_lowerCAmelCase         =       decoder_hidden_size
									_lowerCAmelCase         =       decoder_num_hidden_layers
									_lowerCAmelCase         =       decoder_intermediate_size
									_lowerCAmelCase         =       norm_pix_loss



