

'''simple docstring'''



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu



class 				_snake_case					(   unittest.TestCase			):

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

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

  @property
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							1
      lowerCAmelCase 						=							3
      lowerCAmelCase 						=							(32, 32)

      lowerCAmelCase 						=							floats_tensor((batch_size, num_channels) + sizes      , rng=random.Random(0	)	).to(_SCREAMING_SNAKE_CASE	)
      return image

  @property
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      torch.manual_seed(0	)
      lowerCAmelCase 						=							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      , )
      return model

  @property
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      torch.manual_seed(0	)
      lowerCAmelCase 						=							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      , )
      return model

  @property
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      torch.manual_seed(0	)
      lowerCAmelCase 						=							CLIPTextConfig(
          bos_token_id=0      , eos_token_id=2      , hidden_size=32      , intermediate_size=37      , layer_norm_eps=1e-05      , num_attention_heads=4      , num_hidden_layers=5      , pad_token_id=1      , vocab_size=10_00      , )
      return CLIPTextModel(_SCREAMING_SNAKE_CASE	)

  @property
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      def extract(*_SCREAMING_SNAKE_CASE      , **_SCREAMING_SNAKE_CASE	):



          class 				_snake_case					:

            def __init__(				self	):





                '''simple docstring'''

                lowerCAmelCase 						=							torch.ones([0]	)


            def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE	):





                '''simple docstring'''

                self.pixel_values.to(_SCREAMING_SNAKE_CASE	)
                return self



          return Out()

      return extract

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							'cpu'  # ensure determinism for the device-dependent torch.Generator
      lowerCAmelCase 						=							self.dummy_cond_unet
      lowerCAmelCase 						=							DDIMScheduler(
          beta_start=0.00_085      , beta_end=0.012      , beta_schedule='scaled_linear'      , clip_sample=_SCREAMING_SNAKE_CASE      , set_alpha_to_one=_SCREAMING_SNAKE_CASE      , )

      lowerCAmelCase 						=							self.dummy_vae
      lowerCAmelCase 						=							self.dummy_text_encoder
      lowerCAmelCase 						=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

      # make sure here that pndm scheduler skips prk
      lowerCAmelCase 						=							StableDiffusionPipeline(
          unet=_SCREAMING_SNAKE_CASE      , scheduler=_SCREAMING_SNAKE_CASE      , vae=_SCREAMING_SNAKE_CASE      , text_encoder=_SCREAMING_SNAKE_CASE      , tokenizer=_SCREAMING_SNAKE_CASE      , safety_checker=_SCREAMING_SNAKE_CASE      , feature_extractor=self.dummy_extractor      , )
      lowerCAmelCase 						=							sd_pipe.to(_SCREAMING_SNAKE_CASE	)
      sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							'A painting of a squirrel eating a burger'

      lowerCAmelCase 						=							torch.Generator(device=_SCREAMING_SNAKE_CASE	).manual_seed(0	)
      lowerCAmelCase 						=							sd_pipe([prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=6.0      , num_inference_steps=2      , output_type='np'	)
      lowerCAmelCase 						=							output.images

      lowerCAmelCase 						=							torch.Generator(device=_SCREAMING_SNAKE_CASE	).manual_seed(0	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=6.0      , num_inference_steps=2      , output_type='np'      , return_dict=_SCREAMING_SNAKE_CASE      , )[0]

      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 64, 64, 3)
      lowerCAmelCase 						=							np.array([0.5_756, 0.6_118, 0.5_005, 0.5_041, 0.5_471, 0.4_726, 0.4_976, 0.4_865, 0.4_864]	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							'cpu'  # ensure determinism for the device-dependent torch.Generator
      lowerCAmelCase 						=							self.dummy_cond_unet
      lowerCAmelCase 						=							PNDMScheduler(skip_prk_steps=_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							self.dummy_vae
      lowerCAmelCase 						=							self.dummy_text_encoder
      lowerCAmelCase 						=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

      # make sure here that pndm scheduler skips prk
      lowerCAmelCase 						=							StableDiffusionPipeline(
          unet=_SCREAMING_SNAKE_CASE      , scheduler=_SCREAMING_SNAKE_CASE      , vae=_SCREAMING_SNAKE_CASE      , text_encoder=_SCREAMING_SNAKE_CASE      , tokenizer=_SCREAMING_SNAKE_CASE      , safety_checker=_SCREAMING_SNAKE_CASE      , feature_extractor=self.dummy_extractor      , )
      lowerCAmelCase 						=							sd_pipe.to(_SCREAMING_SNAKE_CASE	)
      sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							'A painting of a squirrel eating a burger'
      lowerCAmelCase 						=							torch.Generator(device=_SCREAMING_SNAKE_CASE	).manual_seed(0	)
      lowerCAmelCase 						=							sd_pipe([prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=6.0      , num_inference_steps=2      , output_type='np'	)

      lowerCAmelCase 						=							output.images

      lowerCAmelCase 						=							torch.Generator(device=_SCREAMING_SNAKE_CASE	).manual_seed(0	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=6.0      , num_inference_steps=2      , output_type='np'      , return_dict=_SCREAMING_SNAKE_CASE      , )[0]

      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							image_from_tuple[0, -3:, -3:, -1]

      assert image.shape == (1, 64, 64, 3)
      lowerCAmelCase 						=							np.array([0.5_125, 0.5_716, 0.4_828, 0.5_060, 0.5_650, 0.4_768, 0.5_185, 0.4_895, 0.4_993]	)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							StableDiffusionPipeline.from_pretrained(
          'hf-internal-testing/tiny-stable-diffusion-lms-pipe'      , safety_checker=_SCREAMING_SNAKE_CASE	)
      assert isinstance(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)
      assert isinstance(pipe.scheduler      , _SCREAMING_SNAKE_CASE	)
      assert pipe.safety_checker is None

      lowerCAmelCase 						=							pipe('example prompt'      , num_inference_steps=2	).images[0]
      assert image is not None

      # check that there's no error when saving a pipeline with one of the models being None
      with tempfile.TemporaryDirectory() as tmpdirname:
          pipe.save_pretrained(_SCREAMING_SNAKE_CASE	)
          lowerCAmelCase 						=							StableDiffusionPipeline.from_pretrained(_SCREAMING_SNAKE_CASE	)

      # sanity check that the pipeline still works
      assert pipe.safety_checker is None
      lowerCAmelCase 						=							pipe('example prompt'      , num_inference_steps=2	).images[0]
      assert image is not None


  @unittest.skipIf(torch_device != 'cuda'      , 'This test requires a GPU'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.dummy_cond_unet
      lowerCAmelCase 						=							PNDMScheduler(skip_prk_steps=_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							self.dummy_vae
      lowerCAmelCase 						=							self.dummy_text_encoder
      lowerCAmelCase 						=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

      # put models in fp16
      lowerCAmelCase 						=							unet.half()
      lowerCAmelCase 						=							vae.half()
      lowerCAmelCase 						=							bert.half()

      # make sure here that pndm scheduler skips prk
      lowerCAmelCase 						=							StableDiffusionPipeline(
          unet=_SCREAMING_SNAKE_CASE      , scheduler=_SCREAMING_SNAKE_CASE      , vae=_SCREAMING_SNAKE_CASE      , text_encoder=_SCREAMING_SNAKE_CASE      , tokenizer=_SCREAMING_SNAKE_CASE      , safety_checker=_SCREAMING_SNAKE_CASE      , feature_extractor=self.dummy_extractor      , )
      lowerCAmelCase 						=							sd_pipe.to(_SCREAMING_SNAKE_CASE	)
      sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							'A painting of a squirrel eating a burger'
      lowerCAmelCase 						=							sd_pipe([prompt]      , num_inference_steps=2      , output_type='np'	).images

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



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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'      , safety_checker=_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config	)
      lowerCAmelCase 						=							sd_pipe.to(_SCREAMING_SNAKE_CASE	)
      sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							(
          'portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle'
          ' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with'
          ' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and'
          ' children from bahnhof zoo, detailed '
      )
      lowerCAmelCase 						=							40_03_66_03_46
      lowerCAmelCase 						=							7

      # without safety guidance (sld_guidance_scale = 0)
      lowerCAmelCase 						=							torch.manual_seed(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=_SCREAMING_SNAKE_CASE      , num_inference_steps=50      , output_type='np'      , width=5_12      , height=5_12      , sld_guidance_scale=0      , )

      lowerCAmelCase 						=							output.images
      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							[0.2_278, 0.2_231, 0.2_249, 0.2_333, 0.2_303, 0.1_885, 0.2_273, 0.2_144, 0.2_176]

      assert image.shape == (1, 5_12, 5_12, 3)

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

      # without safety guidance (strong configuration)
      lowerCAmelCase 						=							torch.manual_seed(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=_SCREAMING_SNAKE_CASE      , num_inference_steps=50      , output_type='np'      , width=5_12      , height=5_12      , sld_guidance_scale=20_00      , sld_warmup_steps=7      , sld_threshold=0.025      , sld_momentum_scale=0.5      , sld_mom_beta=0.7      , )

      lowerCAmelCase 						=							output.images
      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							[0.2_383, 0.2_276, 0.236, 0.2_192, 0.2_186, 0.2_053, 0.1_971, 0.1_901, 0.1_719]

      assert image.shape == (1, 5_12, 5_12, 3)

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

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'      , safety_checker=_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config	)
      lowerCAmelCase 						=							sd_pipe.to(_SCREAMING_SNAKE_CASE	)
      sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							'padme amidala taking a bath artwork, safe for work, no nudity'
      lowerCAmelCase 						=							27_34_97_17_55
      lowerCAmelCase 						=							7

      lowerCAmelCase 						=							torch.manual_seed(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=_SCREAMING_SNAKE_CASE      , num_inference_steps=50      , output_type='np'      , width=5_12      , height=5_12      , sld_guidance_scale=0      , )

      lowerCAmelCase 						=							output.images
      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							[0.3_502, 0.3_622, 0.3_396, 0.3_642, 0.3_478, 0.3_318, 0.35, 0.3_348, 0.3_297]

      assert image.shape == (1, 5_12, 5_12, 3)

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

      lowerCAmelCase 						=							torch.manual_seed(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=_SCREAMING_SNAKE_CASE      , num_inference_steps=50      , output_type='np'      , width=5_12      , height=5_12      , sld_guidance_scale=20_00      , sld_warmup_steps=7      , sld_threshold=0.025      , sld_momentum_scale=0.5      , sld_mom_beta=0.7      , )

      lowerCAmelCase 						=							output.images
      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							[0.5_531, 0.5_206, 0.4_895, 0.5_156, 0.5_182, 0.4_751, 0.4_802, 0.4_803, 0.4_443]

      assert image.shape == (1, 5_12, 5_12, 3)

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


  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'	)
      lowerCAmelCase 						=							sd_pipe.to(_SCREAMING_SNAKE_CASE	)
      sd_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							(
          'the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'
          ' leyendecker'
      )
      lowerCAmelCase 						=							10_44_35_52_34
      lowerCAmelCase 						=							12

      lowerCAmelCase 						=							torch.manual_seed(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=_SCREAMING_SNAKE_CASE      , num_inference_steps=50      , output_type='np'      , width=5_12      , height=5_12      , sld_guidance_scale=0      , )

      lowerCAmelCase 						=							output.images
      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]	)

      assert image.shape == (1, 5_12, 5_12, 3)

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

      lowerCAmelCase 						=							torch.manual_seed(_SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							sd_pipe(
          [prompt]      , generator=_SCREAMING_SNAKE_CASE      , guidance_scale=_SCREAMING_SNAKE_CASE      , num_inference_steps=50      , output_type='np'      , width=5_12      , height=5_12      , sld_guidance_scale=20_00      , sld_warmup_steps=7      , sld_threshold=0.025      , sld_momentum_scale=0.5      , sld_mom_beta=0.7      , )

      lowerCAmelCase 						=							output.images
      lowerCAmelCase 						=							image[0, -3:, -3:, -1]
      lowerCAmelCase 						=							np.array([0.5_818, 0.6_285, 0.6_835, 0.6_019, 0.625, 0.6_754, 0.6_096, 0.6_334, 0.6_561]	)
      assert image.shape == (1, 5_12, 5_12, 3)

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








'''simple docstring'''



def       snake_case   (	snake_case      : dict			) ->  set:


    """simple docstring"""


    lowerCAmelCase 						=							set()
    # edges = list of graph's edges
    lowerCAmelCase 						=							get_edges(snake_case			)

    # While there are still elements in edges list, take an arbitrary edge
    # (from_node, to_node) and add his extremity to chosen_vertices and then
    # remove all arcs adjacent to the from_node and to_node
    while edges:
        lowerCAmelCase						,   lowerCAmelCase 						=							edges.pop()
        chosen_vertices.add(snake_case			)
        chosen_vertices.add(snake_case			)
        for edge in edges.copy():
            if from_node in edge or to_node in edge:
                edges.discard(snake_case			)
    return chosen_vertices


def       snake_case   (	snake_case      : dict			) ->  set:


    """simple docstring"""


    lowerCAmelCase 						=							set()
    for from_node, to_nodes in graph.items():
        for to_node in to_nodes:
            edges.add((from_node, to_node)			)
    return edges


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # graph = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
     # print(f"Matching vertex cover:\n{matching_min_vertex_cover(graph)}")





