





"""simple docstring"""






import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class 						lowerCAmelCase       (   snake_case      ,						snake_case      ,						snake_case      ,						unittest.TestCase				):
       lowerCAmelCase__    			=	StableDiffusionImageVariationPipeline
       lowerCAmelCase__    			=	IMAGE_VARIATION_PARAMS
       lowerCAmelCase__    			=	IMAGE_VARIATION_BATCH_PARAMS
       lowerCAmelCase__    			=	frozenset([]				)
       # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
       lowerCAmelCase__    			=	frozenset([]				)






       def 				__A			( self  ):
              torch.manual_seed(0  )
              _UpperCAmelCase			     =  UNetaDConditionModel(
                  block_out_channels=(32, 64)     ,	layers_per_block=2     ,	sample_size=32     ,	in_channels=4     ,	out_channels=4     ,	down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')     ,	up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')     ,	cross_attention_dim=32     ,	)
              _UpperCAmelCase			     =  PNDMScheduler(skip_prk_steps=a__  )
              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     ,	)
              torch.manual_seed(0  )
              _UpperCAmelCase			     =  CLIPVisionConfig(
                  hidden_size=32     ,	projection_dim=32     ,	intermediate_size=37     ,	layer_norm_eps=1E-05     ,	num_attention_heads=4     ,	num_hidden_layers=5     ,	image_size=32     ,	patch_size=4     ,	)
              _UpperCAmelCase			     =  CLIPVisionModelWithProjection(a__  )
              _UpperCAmelCase			     =  CLIPImageProcessor(crop_size=32     ,	size=32  )

              _UpperCAmelCase			     =  {
                  'unet': unet,
                  'scheduler': scheduler,
                  'vae': vae,
                  'image_encoder': image_encoder,
                  'feature_extractor': feature_extractor,
                  'safety_checker': None,
              }
              return components






       def 				__A			( self     ,	a__     ,	a__=0  ):
              _UpperCAmelCase			     =  floats_tensor((1, 3, 32, 32)     ,	rng=random.Random(a__  )  )
              _UpperCAmelCase			     =  image.cpu().permute(0     ,	2     ,	3     ,	1  )[0]
              _UpperCAmelCase			     =  Image.fromarray(np.uinta(a__  )  ).convert('RGB'  ).resize((32, 32)  )
              if str(a__  ).startswith('mps'  ):
                     _UpperCAmelCase			     =  torch.manual_seed(a__  )
              else:
                     _UpperCAmelCase			     =  torch.Generator(device=a__  ).manual_seed(a__  )
              _UpperCAmelCase			     =  {
                  'image': image,
                  'generator': generator,
                  'num_inference_steps': 2,
                  'guidance_scale': 6.0,
                  'output_type': 'numpy',
              }
              return inputs






       def 				__A			( self  ):
              _UpperCAmelCase			     =  'cpu'  # ensure determinism for the device-dependent torch.Generator
              _UpperCAmelCase			     =  self.get_dummy_components()
              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline(**a__  )
              _UpperCAmelCase			     =  sd_pipe.to(a__  )
              sd_pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  self.get_dummy_inputs(a__  )
              _UpperCAmelCase			     =  sd_pipe(**a__  ).images
              _UpperCAmelCase			     =  image[0, -3:, -3:, -1]

              assert image.shape == (1, 64, 64, 3)
              _UpperCAmelCase			     =  np.array([0.5_239, 0.5_723, 0.4_796, 0.5_049, 0.5_550, 0.4_685, 0.5_329, 0.4_891, 0.4_921]  )

              assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-3






       def 				__A			( self  ):
              _UpperCAmelCase			     =  'cpu'  # ensure determinism for the device-dependent torch.Generator
              _UpperCAmelCase			     =  self.get_dummy_components()
              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline(**a__  )
              _UpperCAmelCase			     =  sd_pipe.to(a__  )
              sd_pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  self.get_dummy_inputs(a__  )
              _UpperCAmelCase			     =  2 * [inputs['image']]
              _UpperCAmelCase			     =  sd_pipe(**a__  )

              _UpperCAmelCase			     =  output.images

              _UpperCAmelCase			     =  image[-1, -3:, -3:, -1]

              assert image.shape == (2, 64, 64, 3)
              _UpperCAmelCase			     =  np.array([0.6_892, 0.5_637, 0.5_836, 0.5_771, 0.6_254, 0.6_409, 0.5_580, 0.5_569, 0.5_289]  )

              assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-3






       def 				__A			( self  ):
              super().test_inference_batch_single_identical(expected_max_diff=3E-3  )



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






       def 				__A			( self  ):
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       def 				__A			( self     ,	a__     ,	a__="cpu"     ,	a__=torch.floataa     ,	a__=0  ):
              _UpperCAmelCase			     =  torch.Generator(device=a__  ).manual_seed(a__  )
              _UpperCAmelCase			     =  load_image(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                  '/stable_diffusion_imgvar/input_image_vermeer.png'  )
              _UpperCAmelCase			     =  np.random.RandomState(a__  ).standard_normal((1, 4, 64, 64)  )
              _UpperCAmelCase			     =  torch.from_numpy(a__  ).to(device=a__     ,	dtype=a__  )
              _UpperCAmelCase			     =  {
                  'image': init_image,
                  'latents': latents,
                  'generator': generator,
                  'num_inference_steps': 3,
                  'guidance_scale': 7.5,
                  'output_type': 'numpy',
              }
              return inputs






       def 				__A			( self  ):
              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline.from_pretrained(
                  'lambdalabs/sd-image-variations-diffusers'     ,	safety_checker=a__  )
              _UpperCAmelCase			     =  sd_pipe.to(a__  )
              sd_pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  self.get_inputs(a__  )
              _UpperCAmelCase			     =  sd_pipe(**a__  ).images
              _UpperCAmelCase			     =  image[0, -3:, -3:, -1].flatten()

              assert image.shape == (1, 5_12, 5_12, 3)
              _UpperCAmelCase			     =  np.array([0.84_491, 0.90_789, 0.75_708, 0.78_734, 0.83_485, 0.70_099, 0.66_938, 0.68_727, 0.61_379]  )
              assert np.abs(image_slice - expected_slice  ).max() < 6E-3






       def 				__A			( self  ):
              _UpperCAmelCase			     =  0

              def callback_fn(a__     ,	a__     ,	a__  ) -> None:
                     _UpperCAmelCase			     =  True
                     nonlocal number_of_steps
                     number_of_steps += 1
                     if step == 1:
                            _UpperCAmelCase			     =  latents.detach().cpu().numpy()
                            assert latents.shape == (1, 4, 64, 64)
                            _UpperCAmelCase			     =  latents[0, -3:, -3:, -1]
                            _UpperCAmelCase			     =  np.array(
                                [-0.1_621, 0.2_837, -0.7_979, -0.1_221, -1.3_057, 0.7_681, -2.1_191, 0.0_464, 1.6_309]  )

                            assert np.abs(latents_slice.flatten() - expected_slice  ).max() < 5E-2
                     elif step == 2:
                            _UpperCAmelCase			     =  latents.detach().cpu().numpy()
                            assert latents.shape == (1, 4, 64, 64)
                            _UpperCAmelCase			     =  latents[0, -3:, -3:, -1]
                            _UpperCAmelCase			     =  np.array([0.6_299, 1.7_500, 1.1_992, -2.1_582, -1.8_994, 0.7_334, -0.7_090, 1.0_137, 1.5_273]  )

                            assert np.abs(latents_slice.flatten() - expected_slice  ).max() < 5E-2

              _UpperCAmelCase			     =  False

              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline.from_pretrained(
                  'fusing/sd-image-variations-diffusers'     ,	safety_checker=a__     ,	torch_dtype=torch.floataa     ,	)
              pipe.to(a__  )
              pipe.set_progress_bar_config(disable=a__  )
              pipe.enable_attention_slicing()

              _UpperCAmelCase			     =  self.get_inputs(a__     ,	dtype=torch.floataa  )
              pipe(**a__     ,	callback=a__     ,	callback_steps=1  )
              assert callback_fn.has_been_called
              assert number_of_steps == inputs["num_inference_steps"]






       def 				__A			( self  ):
              torch.cuda.empty_cache()
              torch.cuda.reset_max_memory_allocated()
              torch.cuda.reset_peak_memory_stats()

              _UpperCAmelCase			     =  'fusing/sd-image-variations-diffusers'
              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline.from_pretrained(
                  a__     ,	safety_checker=a__     ,	torch_dtype=torch.floataa  )
              _UpperCAmelCase			     =  pipe.to(a__  )
              pipe.set_progress_bar_config(disable=a__  )
              pipe.enable_attention_slicing(1  )
              pipe.enable_sequential_cpu_offload()

              _UpperCAmelCase			     =  self.get_inputs(a__     ,	dtype=torch.floataa  )
              _UpperCAmelCase			     =  pipe(**a__  )

              _UpperCAmelCase			     =  torch.cuda.max_memory_allocated()
              # make sure that less than 2.6 GB is allocated
              assert mem_bytes < 2.6 * 10**9



@nightly
@require_torch_gpu
class 						lowerCAmelCase       (   unittest.TestCase				):






       def 				__A			( self  ):
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       def 				__A			( self     ,	a__     ,	a__="cpu"     ,	a__=torch.floataa     ,	a__=0  ):
              _UpperCAmelCase			     =  torch.Generator(device=a__  ).manual_seed(a__  )
              _UpperCAmelCase			     =  load_image(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                  '/stable_diffusion_imgvar/input_image_vermeer.png'  )
              _UpperCAmelCase			     =  np.random.RandomState(a__  ).standard_normal((1, 4, 64, 64)  )
              _UpperCAmelCase			     =  torch.from_numpy(a__  ).to(device=a__     ,	dtype=a__  )
              _UpperCAmelCase			     =  {
                  'image': init_image,
                  'latents': latents,
                  'generator': generator,
                  'num_inference_steps': 50,
                  'guidance_scale': 7.5,
                  'output_type': 'numpy',
              }
              return inputs






       def 				__A			( self  ):
              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'  )
              sd_pipe.to(a__  )
              sd_pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  self.get_inputs(a__  )
              _UpperCAmelCase			     =  sd_pipe(**a__  ).images[0]

              _UpperCAmelCase			     =  load_numpy(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                  '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'  )
              _UpperCAmelCase			     =  np.abs(expected_image - image  ).max()
              assert max_diff < 1E-3






       def 				__A			( self  ):
              _UpperCAmelCase			     =  StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'  )
              _UpperCAmelCase			     =  DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config  )
              sd_pipe.to(a__  )
              sd_pipe.set_progress_bar_config(disable=a__  )

              _UpperCAmelCase			     =  self.get_inputs(a__  )
              _UpperCAmelCase			     =  25
              _UpperCAmelCase			     =  sd_pipe(**a__  ).images[0]

              _UpperCAmelCase			     =  load_numpy(
                  'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                  '/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'  )
              _UpperCAmelCase			     =  np.abs(expected_image - image  ).max()
              assert max_diff < 1E-3













"""simple docstring"""






def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE				)		->							bool:






       """simple docstring"""




       if not isinstance(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE				):
              raise ValueError('Input series is not valid, valid series - [2, 4, 8]'				)
       if len(SCREAMING_SNAKE_CASE				) == 0:
              raise ValueError('Input list must be a non empty list'				)
       if len(SCREAMING_SNAKE_CASE				) == 1:
              return True
       try:
              _UpperCAmelCase			     =  series[1] / series[0]
              for index in range(len(SCREAMING_SNAKE_CASE				) - 1				):
                     if series[index + 1] / series[index] != common_ratio:
                            return False
       except ZeroDivisionError:
              return False
       return True

def    __lowerCamelCase     (							SCREAMING_SNAKE_CASE				)		->							float:






       """simple docstring"""




       if not isinstance(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE				):
              raise ValueError('Input series is not valid, valid series - [2, 4, 8]'				)
       if len(SCREAMING_SNAKE_CASE				) == 0:
              raise ValueError('Input list must be a non empty list'				)
       _UpperCAmelCase			     =  1
       for value in series:
              answer *= value
       return pow(SCREAMING_SNAKE_CASE,1 / len(SCREAMING_SNAKE_CASE				)				)


if __name__ == "__main__":
    import doctest

    doctest.testmod()






