






'''simple docstring'''

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     a_						(      unittest.TestCase    ):

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



        """simple docstring"""






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

  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = StableDiffusionKDiffusionPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""				)
        UpperCamelCase      = sd_pipe.to(_SCREAMING_SNAKE_CASE				)
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE				)

        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=_SCREAMING_SNAKE_CASE      ,		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.0_4_4_7, 0.0_4_9_2, 0.0_4_6_8, 0.0_4_0_8, 0.0_3_8_3, 0.0_4_0_8, 0.0_3_5_4, 0.0_3_8_0, 0.0_3_3_9]				)

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

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



        """simple docstring"""






        UpperCamelCase      = StableDiffusionKDiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""				)
        UpperCamelCase      = sd_pipe.to(_SCREAMING_SNAKE_CASE				)
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE				)

        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=_SCREAMING_SNAKE_CASE      ,		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.1_2_3_7, 0.1_3_2_0, 0.1_4_3_8, 0.1_3_5_9, 0.1_3_9_0, 0.1_1_3_2, 0.1_2_7_7, 0.1_1_7_5, 0.1_1_1_2]				)

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


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



        """simple docstring"""






        UpperCamelCase      = StableDiffusionKDiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""				)
        UpperCamelCase      = sd_pipe.to(_SCREAMING_SNAKE_CASE				)
        sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE				)

        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=_SCREAMING_SNAKE_CASE      ,		guidance_scale=7.5      ,		num_inference_steps=15      ,		output_type="""np"""      ,		use_karras_sigmas=_SCREAMING_SNAKE_CASE      ,		)

        UpperCamelCase      = output.images

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

        assert image.shape == (1, 512, 512, 3)
        UpperCamelCase      = np.array(
            [0.1_1_3_8_1_6_8_9, 0.1_2_1_1_2_9_2_1, 0.1_3_8_9_4_5_7, 0.1_2_5_4_9_6_0_6, 0.1_2_4_4_9_6_4, 0.1_0_8_3_1_5_1_7, 0.1_1_5_6_2_8_6_6, 0.1_0_8_6_7_8_1_6, 0.1_0_4_9_9_0_4_8]				)

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








'''simple docstring'''

import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)






class     a_						(      unittest.TestCase    ):

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = ["""a""", """b""", """c"""]

        # Defaults to last layer if both are None
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[2]				)

        # Out indices set to match out features
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(["""a""", """c"""]      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[0, 2]				)

        # Out features set to match out indices
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		[0, 2]      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[0, 2]				)

        # Out features selected from negative indices
        UpperCamelCase  ,UpperCamelCase      = get_aligned_output_features_output_indices(_SCREAMING_SNAKE_CASE      ,		[-3, -1]      ,		_SCREAMING_SNAKE_CASE				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		["""a""", """c"""]				)
        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		[-3, -1]				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 1)      ,		_SCREAMING_SNAKE_CASE				)

        # Out features must be a list
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(("""a""", """b""")      ,		(0, 1)      ,		["""a""", """b"""]				)

        # Out features must be a subset of stage names
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 1)      ,		["""a"""]				)

        # Out indices must be a list or tuple
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,		0      ,		["""a""", """b"""]				)

        # Out indices must be a subset of stage names
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(_SCREAMING_SNAKE_CASE      ,		(0, 1)      ,		["""a"""]				)

        # Out features and out indices must be the same length
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0,)      ,		["""a""", """b""", """c"""]				)

        # Out features should match out indices
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""a""", """b"""]      ,		(0, 2)      ,		["""a""", """b""", """c"""]				)

        # Out features and out indices should be in order
        with self.assertRaises(_SCREAMING_SNAKE_CASE				):
              verify_out_features_out_indices(["""b""", """a"""]      ,		(0, 1)      ,		["""a""", """b"""]				)

        # Check passes with valid inputs
        verify_out_features_out_indices(["""a""", """b""", """d"""]      ,		(0, 1, -1)      ,		["""a""", """b""", """c""", """d"""]				)


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



        """simple docstring"""






        UpperCamelCase      = BackboneMixin()

        UpperCamelCase      = ["""a""", """b""", """c"""]
        UpperCamelCase      = ["""a""", """c"""]
        UpperCamelCase      = [0, 2]

        # Check that the output features and indices are set correctly
        self.assertEqual(backbone.out_features      ,		["""a""", """c"""]				)
        self.assertEqual(backbone.out_indices      ,		[0, 2]				)

        # Check out features and indices are updated correctly
        UpperCamelCase      = ["""a""", """b"""]
        self.assertEqual(backbone.out_features      ,		["""a""", """b"""]				)
        self.assertEqual(backbone.out_indices      ,		[0, 1]				)

        UpperCamelCase      = [-3, -1]
        self.assertEqual(backbone.out_features      ,		["""a""", """c"""]				)
        self.assertEqual(backbone.out_indices      ,		[-3, -1]				)
