



from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE     				=						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE     				=						{
    "kssteven/ibert-roberta-base": "https://huggingface.co/kssteven/ibert-roberta-base/resolve/main/config.json",
    "kssteven/ibert-roberta-large": "https://huggingface.co/kssteven/ibert-roberta-large/resolve/main/config.json",
    "kssteven/ibert-roberta-large-mnli": (
        "https://huggingface.co/kssteven/ibert-roberta-large-mnli/resolve/main/config.json"
    ),
}



class 	lowerCamelCase      (						lowercase__  ):







					'''simple docstring'''







					lowerCAmelCase_				:    List[Any]									=  'ibert'



					def __init__(			self    ,	lowerCAmelCase=3_0522    ,	lowerCAmelCase=768    ,	lowerCAmelCase=12    ,	lowerCAmelCase=12    ,	lowerCAmelCase=3072    ,	lowerCAmelCase="gelu"    ,	lowerCAmelCase=0.1    ,	lowerCAmelCase=0.1    ,	lowerCAmelCase=512    ,	lowerCAmelCase=2    ,	lowerCAmelCase=0.02    ,	lowerCAmelCase=1e-1_2    ,	lowerCAmelCase=1    ,	lowerCAmelCase=0    ,	lowerCAmelCase=2    ,	lowerCAmelCase="absolute"    ,	lowerCAmelCase=False    ,	lowerCAmelCase="none"    ,	**lowerCAmelCase    ,	):
							super().__init__(pad_token_id=lowerCAmelCase    ,	bos_token_id=lowerCAmelCase    ,	eos_token_id=lowerCAmelCase    ,	**lowerCAmelCase     )

							UpperCAmelCase_						=				vocab_size
							UpperCAmelCase_						=				hidden_size
							UpperCAmelCase_						=				num_hidden_layers
							UpperCAmelCase_						=				num_attention_heads
							UpperCAmelCase_						=				hidden_act
							UpperCAmelCase_						=				intermediate_size
							UpperCAmelCase_						=				hidden_dropout_prob
							UpperCAmelCase_						=				attention_probs_dropout_prob
							UpperCAmelCase_						=				max_position_embeddings
							UpperCAmelCase_						=				type_vocab_size
							UpperCAmelCase_						=				initializer_range
							UpperCAmelCase_						=				layer_norm_eps
							UpperCAmelCase_						=				position_embedding_type
							UpperCAmelCase_						=				quant_mode
							UpperCAmelCase_						=				force_dequant





class 	lowerCamelCase      (						lowercase__  ):







					'''simple docstring'''







					@property
					def    A__		(			self     ):
							if self.task == "multiple-choice":
									UpperCAmelCase_						=				{0: "batch", 1: "choice", 2: "sequence"}
							else:
									UpperCAmelCase_						=				{0: "batch", 1: "sequence"}
							return OrderedDict(
							    [
							        ("input_ids", dynamic_axis),
							        ("attention_mask", dynamic_axis),
							    ]     )






import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

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


enable_full_determinism()



@skip_mps
class 	lowerCamelCase      (						lowercase__,     unittest.TestCase  ):







					'''simple docstring'''







					lowerCAmelCase_				:    int									=  TextToVideoSDPipeline
					lowerCAmelCase_				:    Dict									=  TEXT_TO_IMAGE_PARAMS
					lowerCAmelCase_				:    Optional[Any]									=  TEXT_TO_IMAGE_BATCH_PARAMS
					# No `output_type`.
					lowerCAmelCase_				:    Optional[Any]									=  frozenset(
					    [
					        'num_inference_steps',
					        'generator',
					        'latents',
					        'return_dict',
					        'callback',
					        'callback_steps',
					    ]  )



					def    A__		(			self     ):
							torch.manual_seed(0     )
							UpperCAmelCase_						=				UNetaDConditionModel(
							    block_out_channels=(32, 64, 64, 64)    ,	layers_per_block=2    ,	sample_size=32    ,	in_channels=4    ,	out_channels=4    ,	down_block_types=("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D")    ,	up_block_types=("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D")    ,	cross_attention_dim=32    ,	attention_head_dim=4    ,	)
							UpperCAmelCase_						=				DDIMScheduler(
							    beta_start=0.00085    ,	beta_end=0.012    ,	beta_schedule="scaled_linear"    ,	clip_sample=lowerCAmelCase    ,	set_alpha_to_one=lowerCAmelCase    ,	)
							torch.manual_seed(0     )
							UpperCAmelCase_						=				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     )
							UpperCAmelCase_						=				CLIPTextConfig(
							    bos_token_id=0    ,	eos_token_id=2    ,	hidden_size=32    ,	intermediate_size=37    ,	layer_norm_eps=1e-0_5    ,	num_attention_heads=4    ,	num_hidden_layers=5    ,	pad_token_id=1    ,	vocab_size=1000    ,	hidden_act="gelu"    ,	projection_dim=512    ,	)
							UpperCAmelCase_						=				CLIPTextModel(lowerCAmelCase     )
							UpperCAmelCase_						=				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     )

							UpperCAmelCase_						=				{
							    "unet": unet,
							    "scheduler": scheduler,
							    "vae": vae,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							}
							return components



					def    A__		(			self    ,	lowerCAmelCase    ,	lowerCAmelCase=0     ):
							if str(lowerCAmelCase     ).startswith("mps"     ):
									UpperCAmelCase_						=				torch.manual_seed(lowerCAmelCase     )
							else:
									UpperCAmelCase_						=				torch.Generator(device=lowerCAmelCase     ).manual_seed(lowerCAmelCase     )
							UpperCAmelCase_						=				{
							    "prompt": "A painting of a squirrel eating a burger",
							    "generator": generator,
							    "num_inference_steps": 2,
							    "guidance_scale": 6.0,
							    "output_type": "pt",
							}
							return inputs



					def    A__		(			self     ):
							UpperCAmelCase_						=				"cpu"  # ensure determinism for the device-dependent torch.Generator
							UpperCAmelCase_						=				self.get_dummy_components()
							UpperCAmelCase_						=				TextToVideoSDPipeline(**lowerCAmelCase     )
							UpperCAmelCase_						=				sd_pipe.to(lowerCAmelCase     )
							sd_pipe.set_progress_bar_config(disable=lowerCAmelCase     )

							UpperCAmelCase_						=				self.get_dummy_inputs(lowerCAmelCase     )
							UpperCAmelCase_						=				"np"
							UpperCAmelCase_						=				sd_pipe(**lowerCAmelCase     ).frames
							UpperCAmelCase_						=				frames[0][-3:, -3:, -1]

							assert frames[0].shape == (64, 64, 3)
							UpperCAmelCase_						=				np.array([158.0, 160.0, 153.0, 125.0, 100.0, 121.0, 111.0, 93.0, 113.0]     )

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



					def    A__		(			self     ):
							self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowerCAmelCase    ,	expected_max_diff=3e-3     )



					@unittest.skipIf(
					    torch_device != "cuda" or not is_xformers_available()    ,	reason="XFormers attention is only available with CUDA and `xformers` installed"    ,	)
					def    A__		(			self     ):
							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase    ,	expected_max_diff=1e-2     )



					@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."     )
					def    A__		(			self     ):
							pass



					@unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."     )
					def    A__		(			self     ):
							pass



					@unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."     )
					def    A__		(			self     ):
							pass



					def    A__		(			self     ):
							return super().test_progress_bar()





@slow
@skip_mps
class 	lowerCamelCase      (						unittest.TestCase  ):







					'''simple docstring'''







					def    A__		(			self     ):
							UpperCAmelCase_						=				load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy"     )

							UpperCAmelCase_						=				TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"     )
							UpperCAmelCase_						=				DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
							UpperCAmelCase_						=				pipe.to("cuda"     )

							UpperCAmelCase_						=				"Spiderman is surfing"
							UpperCAmelCase_						=				torch.Generator(device="cpu"     ).manual_seed(0     )

							UpperCAmelCase_						=				pipe(lowerCAmelCase    ,	generator=lowerCAmelCase    ,	num_inference_steps=25    ,	output_type="pt"     ).frames
							UpperCAmelCase_						=				video_frames.cpu().numpy()

							assert np.abs(expected_video - video     ).mean() < 5e-2



					def    A__		(			self     ):
							UpperCAmelCase_						=				load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy"     )

							UpperCAmelCase_						=				TextToVideoSDPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b"     )
							UpperCAmelCase_						=				pipe.to("cuda"     )

							UpperCAmelCase_						=				"Spiderman is surfing"
							UpperCAmelCase_						=				torch.Generator(device="cpu"     ).manual_seed(0     )

							UpperCAmelCase_						=				pipe(lowerCAmelCase    ,	generator=lowerCAmelCase    ,	num_inference_steps=2    ,	output_type="pt"     ).frames
							UpperCAmelCase_						=				video_frames.cpu().numpy()

							assert np.abs(expected_video - video     ).mean() < 5e-2

