
'''simple docstring'''







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaImgaImgPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, 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 			lowerCAmelCase__       (  lowerCamelCase_   ,						unittest.TestCase					):
					lowerCAmelCase_					       =					KandinskyVaaImgaImgPipeline
					lowerCAmelCase_					       =					['''image_embeds''', '''negative_image_embeds''', '''image''']
					lowerCAmelCase_					       =					[
					    '''image_embeds''',
					    '''negative_image_embeds''',
					    '''image''',
					]
					lowerCAmelCase_					       =					[
					    '''generator''',
					    '''height''',
					    '''width''',
					    '''strength''',
					    '''guidance_scale''',
					    '''num_inference_steps''',
					    '''return_dict''',
					    '''guidance_scale''',
					    '''num_images_per_prompt''',
					    '''output_type''',
					    '''return_dict''',
					]
					lowerCAmelCase_					       =					False






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return 32






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return 32






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return self.time_input_dim






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return self.time_input_dim * 4






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											return 1_00






					@property
					def      _snake_case   (       self		):


											"""simple docstring"""





											torch.manual_seed(0		)

											lowercase_     :					Any													=	{
											    '''in_channels''': 4,
											    # Out channels is double in channels because predicts mean and variance
											    '''out_channels''': 8,
											    '''addition_embed_type''': '''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''': '''image_proj''',
											    '''cross_attention_dim''': self.cross_attention_dim,
											    '''attention_head_dim''': 4,
											    '''resnet_time_scale_shift''': '''scale_shift''',
											    '''class_embed_type''': None,
											}

											lowercase_     :					Union[str, Any]													=	UNetaDConditionModel(**__SCREAMING_SNAKE_CASE		)
											return model






					@property
					def      _snake_case   (       self		):


											"""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		):


											"""simple docstring"""





											torch.manual_seed(0		)
											lowercase_     :					str													=	VQModel(**self.dummy_movq_kwargs		)
											return model






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[Any]													=	self.dummy_unet
											lowercase_     :					Dict													=	self.dummy_movq

											lowercase_     :					List[Any]													=	{
											    '''num_train_timesteps''': 10_00,
											    '''beta_schedule''': '''linear''',
											    '''beta_start''': 0.00_085,
											    '''beta_end''': 0.012,
											    '''clip_sample''': False,
											    '''set_alpha_to_one''': False,
											    '''steps_offset''': 0,
											    '''prediction_type''': '''epsilon''',
											    '''thresholding''': False,
											}

											lowercase_     :					List[Any]													=	DDIMScheduler(**__SCREAMING_SNAKE_CASE		)

											lowercase_     :					List[str]													=	{
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''movq''': movq,
											}

											return components






					def      _snake_case   (       self    ,							__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE=0		):


											"""simple docstring"""





											lowercase_     :					str													=	floats_tensor((1, self.text_embedder_hidden_size)    ,							rng=random.Random(__SCREAMING_SNAKE_CASE		)		).to(__SCREAMING_SNAKE_CASE		)
											lowercase_     :					Optional[int]													=	floats_tensor((1, self.text_embedder_hidden_size)    ,							rng=random.Random(seed + 1		)		).to(
											    __SCREAMING_SNAKE_CASE		)
											# create init_image
											lowercase_     :					int													=	floats_tensor((1, 3, 64, 64)    ,							rng=random.Random(__SCREAMING_SNAKE_CASE		)		).to(__SCREAMING_SNAKE_CASE		)
											lowercase_     :					Tuple													=	image.cpu().permute(0    ,							2    ,							3    ,							1		)[0]
											lowercase_     :					int													=	Image.fromarray(np.uinta(__SCREAMING_SNAKE_CASE		)		).convert('''RGB'''		).resize((2_56, 2_56)		)

											if str(__SCREAMING_SNAKE_CASE		).startswith('''mps'''		):
																	lowercase_     :					Any													=	torch.manual_seed(__SCREAMING_SNAKE_CASE		)
											else:
																	lowercase_     :					Optional[int]													=	torch.Generator(device=__SCREAMING_SNAKE_CASE		).manual_seed(__SCREAMING_SNAKE_CASE		)
											lowercase_     :					Optional[Any]													=	{
											    '''image''': init_image,
											    '''image_embeds''': image_embeds,
											    '''negative_image_embeds''': negative_image_embeds,
											    '''generator''': generator,
											    '''height''': 64,
											    '''width''': 64,
											    '''num_inference_steps''': 10,
											    '''guidance_scale''': 7.0,
											    '''strength''': 0.2,
											    '''output_type''': '''np''',
											}
											return inputs






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					str													=	'''cpu'''

											lowercase_     :					Any													=	self.get_dummy_components()

											lowercase_     :					Optional[Any]													=	self.pipeline_class(**__SCREAMING_SNAKE_CASE		)
											lowercase_     :					Dict													=	pipe.to(__SCREAMING_SNAKE_CASE		)

											pipe.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[Any]													=	pipe(**self.get_dummy_inputs(__SCREAMING_SNAKE_CASE		)		)
											lowercase_     :					Optional[Any]													=	output.images

											lowercase_     :					Tuple													=	pipe(
											    **self.get_dummy_inputs(__SCREAMING_SNAKE_CASE		)    ,							return_dict=__SCREAMING_SNAKE_CASE    ,							)[0]

											lowercase_     :					Optional[Any]													=	image[0, -3:, -3:, -1]
											lowercase_     :					int													=	image_from_tuple[0, -3:, -3:, -1]

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

											lowercase_     :					Dict													=	np.array(
											    [0.6_199_778, 0.63_984_406, 0.46_145_785, 0.62_944_984, 0.5_622_215, 0.47_306_132, 0.47_441_456, 0.4_607_606, 0.48_719_263]		)
											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 			lowerCAmelCase__       (  unittest.TestCase					):






					def      _snake_case   (       self		):


											"""simple docstring"""





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






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					List[str]													=	load_numpy(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/kandinskyv22/kandinskyv22_img2img_frog.npy'''		)

											lowercase_     :					List[Any]													=	load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''		)
											lowercase_     :					Tuple													=	'''A red cartoon frog, 4k'''

											lowercase_     :					Union[str, Any]													=	KandinskyVaaPriorPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-2-prior'''    ,							torch_dtype=torch.floataa		)
											pipe_prior.to(__SCREAMING_SNAKE_CASE		)

											lowercase_     :					List[str]													=	KandinskyVaaImgaImgPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-2-decoder'''    ,							torch_dtype=torch.floataa		)
											lowercase_     :					str													=	pipeline.to(__SCREAMING_SNAKE_CASE		)

											pipeline.set_progress_bar_config(disable=__SCREAMING_SNAKE_CASE		)

											lowercase_     :					Optional[Any]													=	torch.Generator(device='''cpu'''		).manual_seed(0		)
											lowercase_						,			lowercase_     :					Tuple													=	pipe_prior(
											    __SCREAMING_SNAKE_CASE    ,							generator=__SCREAMING_SNAKE_CASE    ,							num_inference_steps=5    ,							negative_prompt=''''''    ,							).to_tuple()

											lowercase_     :					Optional[int]													=	pipeline(
											    image=__SCREAMING_SNAKE_CASE    ,							image_embeds=__SCREAMING_SNAKE_CASE    ,							negative_image_embeds=__SCREAMING_SNAKE_CASE    ,							generator=__SCREAMING_SNAKE_CASE    ,							num_inference_steps=1_00    ,							height=7_68    ,							width=7_68    ,							strength=0.2    ,							output_type='''np'''    ,							)

											lowercase_     :					int													=	output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		)





'''simple docstring'''







import logging
from dataclasses import dataclass, field
from pathlib import Path
from typing import Optional, Union

from .generation.configuration_utils import GenerationConfig
from .training_args import TrainingArguments
from .utils import add_start_docstrings


_lowercase			:  Tuple   							=	logging.getLogger(__name__)






@dataclass
@add_start_docstrings(TrainingArguments.__doc__					)
class 			lowerCAmelCase__       (  lowerCamelCase_					):
					lowerCAmelCase_					       =					field(default=lowerCamelCase_   ,						metadata={'''help''': '''Whether to use SortishSampler or not.'''}					)
					lowerCAmelCase_					       =					field(
					    default=lowerCamelCase_   ,						metadata={'''help''': '''Whether to use generate to calculate generative metrics (ROUGE, BLEU).'''}					)
					lowerCAmelCase_					       =					field(
					    default=lowerCamelCase_   ,						metadata={
					        '''help''': (
					            '''The `max_length` to use on each evaluation loop when `predict_with_generate=True`. Will default '''
					            '''to the `max_length` value of the model configuration.'''
					        )
					    }   ,						)
					lowerCAmelCase_					       =					field(
					    default=lowerCamelCase_   ,						metadata={
					        '''help''': (
					            '''The `num_beams` to use on each evaluation loop when `predict_with_generate=True`. Will default '''
					            '''to the `num_beams` value of the model configuration.'''
					        )
					    }   ,						)
					lowerCAmelCase_					       =					field(
					    default=lowerCamelCase_   ,						metadata={
					        '''help''': '''Model id, file path or url pointing to a GenerationConfig json file, to use during prediction.'''
					    }   ,						)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Dict													=	super().to_dict()
											for k, v in d.items():
																	if isinstance(__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE		):
																							lowercase_     :					str													=	v.to_dict()
											return d



