
import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


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



  def __UpperCamelCase			(			self	)  -> Optional[Any]:
    """simple docstring"""
    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()



  def __UpperCamelCase			(			self	)  -> List[str]:
    """simple docstring"""
    UpperCamelCase          =					StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'	)
    UpperCamelCase          =					sd_pipe.to(_A	)
    sd_pipe.set_progress_bar_config(disable=_A	)

    sd_pipe.set_scheduler('sample_euler'	)

    UpperCamelCase          =					'A painting of a squirrel eating a burger'
    UpperCamelCase          =					torch.manual_seed(0	)
    UpperCamelCase          =					sd_pipe([prompt]    ,				generator=_A    ,				guidance_scale=9.0    ,				num_inference_steps=20    ,				output_type='np'	)

    UpperCamelCase          =					output.images

    UpperCamelCase          =					image[0, -3:, -3:, -1]

    assert image.shape == (1, 512, 512, 3)
    UpperCamelCase          =					np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]	)

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



  def __UpperCamelCase			(			self	)  -> Tuple:
    """simple docstring"""
    UpperCamelCase          =					StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'	)
    UpperCamelCase          =					sd_pipe.to(_A	)
    sd_pipe.set_progress_bar_config(disable=_A	)

    sd_pipe.set_scheduler('sample_euler'	)

    UpperCamelCase          =					'A painting of a squirrel eating a burger'
    UpperCamelCase          =					torch.manual_seed(0	)
    UpperCamelCase          =					sd_pipe([prompt]    ,				generator=_A    ,				guidance_scale=9.0    ,				num_inference_steps=20    ,				output_type='np'	)

    UpperCamelCase          =					output.images

    UpperCamelCase          =					image[0, -3:, -3:, -1]

    assert image.shape == (1, 512, 512, 3)
    UpperCamelCase          =					np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]	)

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



  def __UpperCamelCase			(			self	)  -> Dict:
    """simple docstring"""
    UpperCamelCase          =					StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'	)
    UpperCamelCase          =					sd_pipe.to(_A	)
    sd_pipe.set_progress_bar_config(disable=_A	)

    sd_pipe.set_scheduler('sample_dpmpp_2m'	)

    UpperCamelCase          =					'A painting of a squirrel eating a burger'
    UpperCamelCase          =					torch.manual_seed(0	)
    UpperCamelCase          =					sd_pipe(
        [prompt]    ,				generator=_A    ,				guidance_scale=7.5    ,				num_inference_steps=15    ,				output_type='np'    ,				use_karras_sigmas=_A    ,				)

    UpperCamelCase          =					output.images

    UpperCamelCase          =					image[0, -3:, -3:, -1]

    assert image.shape == (1, 512, 512, 3)
    UpperCamelCase          =					np.array(
        [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]	)

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


import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation


class     lowercase (		unittest.TestCase       ):



		def __UpperCamelCase			(			self	)  -> List[Any]:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('swish'	)

				self.assertIsInstance(A_    ,				nn.SiLU	)

				self.assertEqual(act(torch.tensor(-100    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)



		def __UpperCamelCase			(			self	)  -> Optional[int]:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('silu'	)

				self.assertIsInstance(A_    ,				nn.SiLU	)

				self.assertEqual(act(torch.tensor(-100    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)



		def __UpperCamelCase			(			self	)  -> str:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('mish'	)

				self.assertIsInstance(A_    ,				nn.Mish	)

				self.assertEqual(act(torch.tensor(-200    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)



		def __UpperCamelCase			(			self	)  -> Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase          =					get_activation('gelu'	)

				self.assertIsInstance(A_    ,				nn.GELU	)

				self.assertEqual(act(torch.tensor(-100    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertNotEqual(act(torch.tensor(-1    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(0    ,				dtype=torch.floataa	)	).item()    ,				0	)
				self.assertEqual(act(torch.tensor(20    ,				dtype=torch.floataa	)	).item()    ,				20	)
