




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

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class        SCREAMING_SNAKE_CASE(				__A   ,      unittest.TestCase     ):
       snake_case_ :     Any    =					KandinskyPipeline
       snake_case_ :     List[Any]    =					[
           """prompt""",
           """image_embeds""",
           """negative_image_embeds""",
       ]
       snake_case_ :     Union[str, Any]    =					["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
       snake_case_ :     List[Any]    =					[
           """generator""",
           """height""",
           """width""",
           """latents""",
           """guidance_scale""",
           """negative_prompt""",
           """num_inference_steps""",
           """return_dict""",
           """guidance_scale""",
           """num_images_per_prompt""",
           """output_type""",
           """return_dict""",
       ]
       snake_case_ :     Union[str, Any]    =					False

       @property
       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           return 32

       @property
       def     snake_case__			(    self     )    ->					str:

           """simple docstring"""



           return 32

       @property
       def     snake_case__			(    self     )    ->					Tuple:

           """simple docstring"""



           return self.time_input_dim

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

           """simple docstring"""



           return self.time_input_dim * 4

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

           """simple docstring"""



           return 100

       @property
       def     snake_case__			(    self     )    ->					Tuple:

           """simple docstring"""



           __lowercase							=						XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""     )
           return tokenizer

       @property
       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



           torch.manual_seed(0     )
           __lowercase							=						MCLIPConfig(
               numDims=self.cross_attention_dim					,		transformerDimensions=self.text_embedder_hidden_size					,		hidden_size=self.text_embedder_hidden_size					,		intermediate_size=37					,		num_attention_heads=4					,		num_hidden_layers=5					,		vocab_size=1005					,		)

           __lowercase							=						MultilingualCLIP(lowerCamelCase__     )
           __lowercase							=						text_encoder.eval()

           return text_encoder

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

           """simple docstring"""



           torch.manual_seed(0     )

           __lowercase							=						{
               """in_channels""": 4,
               # Out channels is double in channels because predicts mean and variance
               """out_channels""": 8,
               """addition_embed_type""": """text_image""",
               """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
               """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
               """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
               """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
               """layers_per_block""": 1,
               """encoder_hid_dim""": self.text_embedder_hidden_size,
               """encoder_hid_dim_type""": """text_image_proj""",
               """cross_attention_dim""": self.cross_attention_dim,
               """attention_head_dim""": 4,
               """resnet_time_scale_shift""": """scale_shift""",
               """class_embed_type""": None,
           }

           __lowercase							=						UNetaDConditionModel(**lowerCamelCase__     )
           return model

       @property
       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           return {
               "block_out_channels": [32, 64],
               "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
               "in_channels": 3,
               "latent_channels": 4,
               "layers_per_block": 1,
               "norm_num_groups": 8,
               "norm_type": "spatial",
               "num_vq_embeddings": 12,
               "out_channels": 3,
               "up_block_types": [
                   "AttnUpDecoderBlock2D",
                   "UpDecoderBlock2D",
               ],
               "vq_embed_dim": 4,
           }

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

           """simple docstring"""



           torch.manual_seed(0     )
           __lowercase							=						VQModel(**self.dummy_movq_kwargs     )
           return model

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

           """simple docstring"""



           __lowercase							=						self.dummy_text_encoder
           __lowercase							=						self.dummy_tokenizer
           __lowercase							=						self.dummy_unet
           __lowercase							=						self.dummy_movq

           __lowercase							=						DDIMScheduler(
               num_train_timesteps=1000					,		beta_schedule="""linear"""					,		beta_start=0.0_00_85					,		beta_end=0.0_12					,		clip_sample=lowerCamelCase__					,		set_alpha_to_one=lowerCamelCase__					,		steps_offset=1					,		prediction_type="""epsilon"""					,		thresholding=lowerCamelCase__					,		)

           __lowercase							=						{
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """unet""": unet,
               """scheduler""": scheduler,
               """movq""": movq,
           }
           return components

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__=0     )    ->					Union[str, Any]:

           """simple docstring"""



           __lowercase							=						floats_tensor((1, self.cross_attention_dim)					,		rng=random.Random(lowerCamelCase__     )     ).to(lowerCamelCase__     )
           __lowercase							=						floats_tensor((1, self.cross_attention_dim)					,		rng=random.Random(seed + 1     )     ).to(lowerCamelCase__     )
           if str(lowerCamelCase__     ).startswith("""mps"""     ):
               __lowercase							=						torch.manual_seed(lowerCamelCase__     )
           else:
               __lowercase							=						torch.Generator(device=lowerCamelCase__     ).manual_seed(lowerCamelCase__     )
           __lowercase							=						{
               """prompt""": """horse""",
               """image_embeds""": image_embeds,
               """negative_image_embeds""": negative_image_embeds,
               """generator""": generator,
               """height""": 64,
               """width""": 64,
               """guidance_scale""": 4.0,
               """num_inference_steps""": 2,
               """output_type""": """np""",
           }
           return inputs




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

           """simple docstring"""



           __lowercase							=						"""cpu"""

           __lowercase							=						self.get_dummy_components()

           __lowercase							=						self.pipeline_class(**lowerCamelCase__     )
           __lowercase							=						pipe.to(lowerCamelCase__     )

           pipe.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase							=						pipe(**self.get_dummy_inputs(lowerCamelCase__     )     )
           __lowercase							=						output.images

           __lowercase							=						pipe(
               **self.get_dummy_inputs(lowerCamelCase__     )					,		return_dict=lowerCamelCase__					,		)[0]

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

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

           __lowercase							=						np.array(
               [0.32_86_63, 1.0, 0.23_21_68_73, 1.0, 0.92_71_75_64, 0.4_63_90_46, 0.96_89_47_77, 0.31_71_33_78, 0.6_29_39_53]     )

           assert (
               np.abs(image_slice.flatten() - expected_slice     ).max() < 1E-2
           ), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
           assert (
               np.abs(image_from_tuple_slice.flatten() - expected_slice     ).max() < 1E-2
           ), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'






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

       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



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




       def     snake_case__			(    self     )    ->					str:

           """simple docstring"""



           __lowercase							=						load_numpy(
               """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
               """/kandinsky/kandinsky_text2img_cat_fp16.npy"""     )

           __lowercase							=						KandinskyPriorPipeline.from_pretrained(
               """kandinsky-community/kandinsky-2-1-prior"""					,		torch_dtype=torch.floataa     )
           pipe_prior.to(lowerCamelCase__     )

           __lowercase							=						KandinskyPipeline.from_pretrained("""kandinsky-community/kandinsky-2-1"""					,		torch_dtype=torch.floataa     )
           __lowercase							=						pipeline.to(lowerCamelCase__     )
           pipeline.set_progress_bar_config(disable=lowerCamelCase__     )

           __lowercase							=						"""red cat, 4k photo"""

           __lowercase							=						torch.Generator(device="""cuda"""     ).manual_seed(0     )
           __lowercase				,__lowercase							=						pipe_prior(
               lowerCamelCase__					,		generator=lowerCamelCase__					,		num_inference_steps=5					,		negative_prompt=""""""					,		).to_tuple()

           __lowercase							=						torch.Generator(device="""cuda"""     ).manual_seed(0     )
           __lowercase							=						pipeline(
               lowerCamelCase__					,		image_embeds=lowerCamelCase__					,		negative_image_embeds=lowerCamelCase__					,		generator=lowerCamelCase__					,		num_inference_steps=100					,		output_type="""np"""					,		)

           __lowercase							=						output.images[0]

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

           assert_mean_pixel_difference(lowerCamelCase__					,		lowerCamelCase__     )










'''simple docstring'''
import torch

from diffusers import HeunDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest






class        SCREAMING_SNAKE_CASE(				__A     ):
       snake_case_ :     Any    =					(HeunDiscreteScheduler,)
       snake_case_ :     Any    =					10

       def     snake_case__			(    self					,		**lowerCamelCase__     )    ->					int:

           """simple docstring"""



           __lowercase							=						{
               """num_train_timesteps""": 1100,
               """beta_start""": 0.00_01,
               """beta_end""": 0.02,
               """beta_schedule""": """linear""",
           }

           config.update(**lowerCamelCase__     )
           return config

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

           """simple docstring"""



           for timesteps in [10, 50, 100, 1000]:
               self.check_over_configs(num_train_timesteps=lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



           for beta_start, beta_end in zip([0.0_00_01, 0.00_01, 0.0_01]					,		[0.00_02, 0.0_02, 0.02]     ):
               self.check_over_configs(beta_start=lowerCamelCase__					,		beta_end=lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					Any:

           """simple docstring"""



           for schedule in ["linear", "scaled_linear", "exp"]:
               self.check_over_configs(beta_schedule=lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           for clip_sample_range in [1.0, 2.0, 3.0]:
               self.check_over_configs(clip_sample_range=lowerCamelCase__					,		clip_sample=lowerCamelCase__     )

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

           """simple docstring"""



           for prediction_type in ["epsilon", "v_prediction", "sample"]:
               self.check_over_configs(prediction_type=lowerCamelCase__     )

       def     snake_case__			(    self     )    ->					str:

           """simple docstring"""



           __lowercase							=						self.scheduler_classes[0]
           __lowercase							=						self.get_scheduler_config()
           __lowercase							=						scheduler_class(**lowerCamelCase__     )

           scheduler.set_timesteps(self.num_inference_steps     )

           __lowercase							=						self.dummy_model()
           __lowercase							=						self.dummy_sample_deter * scheduler.init_noise_sigma
           __lowercase							=						sample.to(lowerCamelCase__     )

           for i, t in enumerate(scheduler.timesteps     ):
               __lowercase							=						scheduler.scale_model_input(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						model(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						scheduler.step(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )
               __lowercase							=						output.prev_sample

           __lowercase							=						torch.sum(torch.abs(lowerCamelCase__     )     )
           __lowercase							=						torch.mean(torch.abs(lowerCamelCase__     )     )

           if torch_device in ["cpu", "mps"]:
               assert abs(result_sum.item() - 0.12_33     ) < 1E-2
               assert abs(result_mean.item() - 0.00_02     ) < 1E-3
           else:
               # CUDA
               assert abs(result_sum.item() - 0.12_33     ) < 1E-2
               assert abs(result_mean.item() - 0.00_02     ) < 1E-3

       def     snake_case__			(    self     )    ->					str:

           """simple docstring"""



           __lowercase							=						self.scheduler_classes[0]
           __lowercase							=						self.get_scheduler_config(prediction_type="""v_prediction"""     )
           __lowercase							=						scheduler_class(**lowerCamelCase__     )

           scheduler.set_timesteps(self.num_inference_steps     )

           __lowercase							=						self.dummy_model()
           __lowercase							=						self.dummy_sample_deter * scheduler.init_noise_sigma
           __lowercase							=						sample.to(lowerCamelCase__     )

           for i, t in enumerate(scheduler.timesteps     ):
               __lowercase							=						scheduler.scale_model_input(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						model(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						scheduler.step(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )
               __lowercase							=						output.prev_sample

           __lowercase							=						torch.sum(torch.abs(lowerCamelCase__     )     )
           __lowercase							=						torch.mean(torch.abs(lowerCamelCase__     )     )

           if torch_device in ["cpu", "mps"]:
               assert abs(result_sum.item() - 4.6_9_3_4E-0_7     ) < 1E-2
               assert abs(result_mean.item() - 6.1_1_1_2E-1_0     ) < 1E-3
           else:
               # CUDA
               assert abs(result_sum.item() - 4.6_9_3_4_2_8_6_5_0_1_7_0_9_7_2E-0_7     ) < 1E-2
               assert abs(result_mean.item() - 0.00_02     ) < 1E-3

       def     snake_case__			(    self     )    ->					Dict:

           """simple docstring"""



           __lowercase							=						self.scheduler_classes[0]
           __lowercase							=						self.get_scheduler_config()
           __lowercase							=						scheduler_class(**lowerCamelCase__     )

           scheduler.set_timesteps(self.num_inference_steps					,		device=lowerCamelCase__     )

           __lowercase							=						self.dummy_model()
           __lowercase							=						self.dummy_sample_deter.to(lowerCamelCase__     ) * scheduler.init_noise_sigma

           for t in scheduler.timesteps:
               __lowercase							=						scheduler.scale_model_input(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						model(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						scheduler.step(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )
               __lowercase							=						output.prev_sample

           __lowercase							=						torch.sum(torch.abs(lowerCamelCase__     )     )
           __lowercase							=						torch.mean(torch.abs(lowerCamelCase__     )     )

           if str(lowerCamelCase__     ).startswith("""cpu"""     ):
               # The following sum varies between 148 and 156 on mps. Why?
               assert abs(result_sum.item() - 0.12_33     ) < 1E-2
               assert abs(result_mean.item() - 0.00_02     ) < 1E-3
           elif str(lowerCamelCase__     ).startswith("""mps"""     ):
               # Larger tolerance on mps
               assert abs(result_mean.item() - 0.00_02     ) < 1E-2
           else:
               # CUDA
               assert abs(result_sum.item() - 0.12_33     ) < 1E-2
               assert abs(result_mean.item() - 0.00_02     ) < 1E-3




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

           """simple docstring"""



           __lowercase							=						self.scheduler_classes[0]
           __lowercase							=						self.get_scheduler_config()
           __lowercase							=						scheduler_class(**lowerCamelCase__					,		use_karras_sigmas=lowerCamelCase__     )

           scheduler.set_timesteps(self.num_inference_steps					,		device=lowerCamelCase__     )

           __lowercase							=						self.dummy_model()
           __lowercase							=						self.dummy_sample_deter.to(lowerCamelCase__     ) * scheduler.init_noise_sigma
           __lowercase							=						sample.to(lowerCamelCase__     )

           for t in scheduler.timesteps:
               __lowercase							=						scheduler.scale_model_input(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						model(lowerCamelCase__					,		lowerCamelCase__     )

               __lowercase							=						scheduler.step(lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__     )
               __lowercase							=						output.prev_sample

           __lowercase							=						torch.sum(torch.abs(lowerCamelCase__     )     )
           __lowercase							=						torch.mean(torch.abs(lowerCamelCase__     )     )

           assert abs(result_sum.item() - 0.0_00_15     ) < 1E-2
           assert abs(result_mean.item() - 1.9_8_6_9_5_5_4_5_3_5_0_3_4_6_9_5E-0_7     ) < 1E-2




