



"""simple docstring"""







import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
class        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					List[str]   	=				KandinskyVaaPriorPipeline
		lowerCAmelCase			:					str   	=				["prompt"]
		lowerCAmelCase			:					List[str]   	=				["prompt", "negative_prompt"]
		lowerCAmelCase			:					List[str]   	=				[
		    "num_images_per_prompt",
		    "generator",
		    "num_inference_steps",
		    "latents",
		    "negative_prompt",
		    "guidance_scale",
		    "output_type",
		    "return_dict",
		]
		lowerCAmelCase			:					str   	=				False







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






				"""simple docstring"""



				return 32







		@property
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Union[str, Any]:






				"""simple docstring"""



				return 32







		@property
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		int:






				"""simple docstring"""



				return self.time_input_dim







		@property
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		List[str]:






				"""simple docstring"""



				return self.time_input_dim * 4







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






				"""simple docstring"""



				return 100







		@property
		def 					UpperCAmelCase    (	self						:  int						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    Any				=			CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''						)
				return tokenizer







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






				"""simple docstring"""



				torch.manual_seed(0						)
				lowercase__   :    Any				=			CLIPTextConfig(
				    bos_token_id=0			,eos_token_id=2			,hidden_size=self.text_embedder_hidden_size			,projection_dim=self.text_embedder_hidden_size			,intermediate_size=37			,layer_norm_eps=1e-05			,num_attention_heads=4			,num_hidden_layers=5			,pad_token_id=1			,vocab_size=1_000			,)
				return CLIPTextModelWithProjection(_snake_case						)







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






				"""simple docstring"""



				torch.manual_seed(0						)

				lowercase__   :    Optional[int]				=			{
				    '''num_attention_heads''': 2,
				    '''attention_head_dim''': 12,
				    '''embedding_dim''': self.text_embedder_hidden_size,
				    '''num_layers''': 1,
				}

				lowercase__   :    Tuple				=			PriorTransformer(**_snake_case						)
				# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
				lowercase__   :    Union[str, Any]				=			nn.Parameter(torch.ones(model.clip_std.shape						)						)
				return model







		@property
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Optional[Any]:






				"""simple docstring"""



				torch.manual_seed(0						)
				lowercase__   :    str				=			CLIPVisionConfig(
				    hidden_size=self.text_embedder_hidden_size			,image_size=224			,projection_dim=self.text_embedder_hidden_size			,intermediate_size=37			,num_attention_heads=4			,num_channels=3			,num_hidden_layers=5			,patch_size=14			,)

				lowercase__   :    Any				=			CLIPVisionModelWithProjection(_snake_case						)
				return model







		@property
		def 					UpperCAmelCase    (	self						:  int						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			CLIPImageProcessor(
				    crop_size=224			,do_center_crop=_snake_case			,do_normalize=_snake_case			,do_resize=_snake_case			,image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]			,image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]			,resample=3			,size=224			,)

				return image_processor







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






				"""simple docstring"""



				lowercase__   :    List[str]				=			self.dummy_prior
				lowercase__   :    Optional[Any]				=			self.dummy_image_encoder
				lowercase__   :    Optional[int]				=			self.dummy_text_encoder
				lowercase__   :    Optional[int]				=			self.dummy_tokenizer
				lowercase__   :    Tuple				=			self.dummy_image_processor

				lowercase__   :    Dict				=			UnCLIPScheduler(
				    variance_type='''fixed_small_log'''			,prediction_type='''sample'''			,num_train_timesteps=1_000			,clip_sample=_snake_case			,clip_sample_range=10.0			,)

				lowercase__   :    Optional[Any]				=			{
				    '''prior''': prior,
				    '''image_encoder''': image_encoder,
				    '''text_encoder''': text_encoder,
				    '''tokenizer''': tokenizer,
				    '''scheduler''': scheduler,
				    '''image_processor''': image_processor,
				}

				return components







		def 					UpperCAmelCase    (	self						:  int			,_snake_case						:  Optional[int]			,_snake_case						:  int=0						)					->		Optional[int]:






				"""simple docstring"""



				if str(_snake_case						).startswith('''mps'''						):
						lowercase__   :    Optional[int]				=			torch.manual_seed(_snake_case						)
				else:
						lowercase__   :    str				=			torch.Generator(device=_snake_case						).manual_seed(_snake_case						)
				lowercase__   :    str				=			{
				    '''prompt''': '''horse''',
				    '''generator''': generator,
				    '''guidance_scale''': 4.0,
				    '''num_inference_steps''': 2,
				    '''output_type''': '''np''',
				}
				return inputs







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    Dict				=			'''cpu'''

				lowercase__   :    Optional[int]				=			self.get_dummy_components()

				lowercase__   :    Optional[int]				=			self.pipeline_class(**_snake_case						)
				lowercase__   :    Union[str, Any]				=			pipe.to(_snake_case						)

				pipe.set_progress_bar_config(disable=_snake_case						)

				lowercase__   :    Optional[Any]				=			pipe(**self.get_dummy_inputs(_snake_case						)						)
				lowercase__   :    List[Any]				=			output.image_embeds

				lowercase__   :    Dict				=			pipe(
				    **self.get_dummy_inputs(_snake_case						)			,return_dict=_snake_case			,)[0]

				lowercase__   :    Any				=			image[0, -10:]
				lowercase__   :    int				=			image_from_tuple[0, -10:]

				assert image.shape == (1, 32)

				lowercase__   :    Optional[Any]				=			np.array(
				    [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]						)

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







		@skip_mps
		def 					UpperCAmelCase    (	self						:  List[str]						)					->		int:






				"""simple docstring"""



				lowercase__   :    Any				=			torch_device == '''cpu'''
				lowercase__   :    Optional[Any]				=			True
				lowercase__   :    int				=			False

				self._test_inference_batch_single_identical(
				    test_max_difference=_snake_case			,relax_max_difference=_snake_case			,test_mean_pixel_difference=_snake_case			,)







		@skip_mps
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__   :    str				=			torch_device == '''cpu'''
				lowercase__   :    Union[str, Any]				=			False

				self._test_attention_slicing_forward_pass(
				    test_max_difference=_snake_case			,test_mean_pixel_difference=_snake_case			,)





"""simple docstring"""







import unittest

from accelerate import debug_launcher
from accelerate.test_utils import require_cpu, test_ops, test_script
@require_cpu
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		str:






				"""simple docstring"""



				debug_launcher(test_script.main						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Tuple:






				"""simple docstring"""



				debug_launcher(test_ops.main						)
