

'''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__ ( _snake_case  ,  unittest.TestCase     ):
    lowercase		   =						KandinskyVaaPriorPipeline
    lowercase		   =						["prompt"]
    lowercase		   =						["prompt", "negative_prompt"]
    lowercase		   =						[
        "num_images_per_prompt",
        "generator",
        "num_inference_steps",
        "latents",
        "negative_prompt",
        "guidance_scale",
        "output_type",
        "return_dict",
    ]
    lowercase		   =						False



    @property
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           return 32



    @property
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           return 32



    @property
    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           return self.time_input_dim



    @property
    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           return self.time_input_dim * 4



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return 100



    @property
    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )
           return tokenizer



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





           '''simple docstring'''
           torch.manual_seed(0    )
           A_		   = 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-0_5						,			num_attention_heads=4						,			num_hidden_layers=5						,			pad_token_id=1						,			vocab_size=1000						,			)
           return CLIPTextModelWithProjection(UpperCamelCase__    )



    @property
    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           torch.manual_seed(0    )

           A_		   = {
               """num_attention_heads""": 2,
               """attention_head_dim""": 12,
               """embedding_dim""": self.text_embedder_hidden_size,
               """num_layers""": 1,
           }

           A_		   = PriorTransformer(**UpperCamelCase__    )
           # 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
           A_		   = nn.Parameter(torch.ones(model.clip_std.shape    )    )
           return model



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





           '''simple docstring'''
           torch.manual_seed(0    )
           A_		   = 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						,			)

           A_		   = CLIPVisionModelWithProjection(UpperCamelCase__    )
           return model



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





           '''simple docstring'''
           A_		   = CLIPImageProcessor(
               crop_size=224						,			do_center_crop=UpperCamelCase__						,			do_normalize=UpperCamelCase__						,			do_resize=UpperCamelCase__						,			image_mean=[0.48145466, 0.4578275, 0.40821073]						,			image_std=[0.26862954, 0.26130258, 0.27577711]						,			resample=3						,			size=224						,			)

           return image_processor



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





           '''simple docstring'''
           A_		   = self.dummy_prior
           A_		   = self.dummy_image_encoder
           A_		   = self.dummy_text_encoder
           A_		   = self.dummy_tokenizer
           A_		   = self.dummy_image_processor

           A_		   = UnCLIPScheduler(
               variance_type="""fixed_small_log"""						,			prediction_type="""sample"""						,			num_train_timesteps=1000						,			clip_sample=UpperCamelCase__						,			clip_sample_range=10.0						,			)

           A_		   = {
               """prior""": prior,
               """image_encoder""": image_encoder,
               """text_encoder""": text_encoder,
               """tokenizer""": tokenizer,
               """scheduler""": scheduler,
               """image_processor""": image_processor,
           }

           return components



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__=0    )  -> Any:





           '''simple docstring'''
           if str(UpperCamelCase__    ).startswith("""mps"""    ):
                  A_		   = torch.manual_seed(UpperCamelCase__    )
           else:
                  A_		   = torch.Generator(device=UpperCamelCase__    ).manual_seed(UpperCamelCase__    )
           A_		   = {
               """prompt""": """horse""",
               """generator""": generator,
               """guidance_scale""": 4.0,
               """num_inference_steps""": 2,
               """output_type""": """np""",
           }
           return inputs



    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_		   = """cpu"""

           A_		   = self.get_dummy_components()

           A_		   = self.pipeline_class(**UpperCamelCase__    )
           A_		   = pipe.to(UpperCamelCase__    )

           pipe.set_progress_bar_config(disable=UpperCamelCase__    )

           A_		   = pipe(**self.get_dummy_inputs(UpperCamelCase__    )    )
           A_		   = output.image_embeds

           A_		   = pipe(
               **self.get_dummy_inputs(UpperCamelCase__    )						,			return_dict=UpperCamelCase__						,			)[0]

           A_		   = image[0, -10:]
           A_		   = image_from_tuple[0, -10:]

           assert image.shape == (1, 32)

           A_		   = 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    snake_case_     (   self    )  -> List[str]:





           '''simple docstring'''
           A_		   = torch_device == """cpu"""
           A_		   = True
           A_		   = False

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







    @skip_mps
    def    snake_case_     (   self    )  -> Tuple:





           '''simple docstring'''
           A_		   = torch_device == """cpu"""
           A_		   = False

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



'''simple docstring'''







import math
import sys
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     int:
       if number != int(UpperCAmelCase__			):
              raise ValueError("""the value of input must be a natural number"""			)
       if number < 0:
              raise ValueError("""the value of input must not be a negative number"""			)
       if number == 0:
              return 1
       A_		   = [-1] * (number + 1)
       A_		   = 0
       for i in range(1,    number + 1			):
              A_		   = sys.maxsize
              A_		   = int(math.sqrt(UpperCAmelCase__			)			)
              for j in range(1,    root + 1			):
                     A_		   = 1 + answers[i - (j**2)]
                     A_		   = min(UpperCAmelCase__,    UpperCAmelCase__			)
              A_		   = answer
       return answers[number]


if __name__ == "__main__":
      import doctest

      doctest.testmod()
