




"""simple docstring"""
import inspect
import unittest

from transformers import ResNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
    from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor







class  _SCREAMING_SNAKE_CASE       :



 '''simple docstring'''





 def __init__(self					,     lowerCAmelCase__					,     lowerCAmelCase__=3					,     lowerCAmelCase__=32					,     lowerCAmelCase__=3					,     lowerCAmelCase__=10					,     lowerCAmelCase__=[10, 20, 30, 40]					,     lowerCAmelCase__=[1, 1, 2, 1]					,     lowerCAmelCase__=True					,     lowerCAmelCase__=True					,     lowerCAmelCase__="relu"					,     lowerCAmelCase__=3					,     lowerCAmelCase__=None					,     lowerCAmelCase__=["stage2", "stage3", "stage4"]					,     lowerCAmelCase__=[2, 3, 4]					,     ):

  '''simple docstring'''







  _UpperCamelCase      :	Optional[int]					      =  parent
  _UpperCamelCase      :	Optional[Any]					      =  batch_size
  _UpperCamelCase      :	Any					      =  image_size
  _UpperCamelCase      :	Optional[int]					      =  num_channels
  _UpperCamelCase      :	List[str]					      =  embeddings_size
  _UpperCamelCase      :	Optional[int]					      =  hidden_sizes
  _UpperCamelCase      :	Dict					      =  depths
  _UpperCamelCase      :	List[Any]					      =  is_training
  _UpperCamelCase      :	Optional[int]					      =  use_labels
  _UpperCamelCase      :	Dict					      =  hidden_act
  _UpperCamelCase      :	Union[str, Any]					      =  num_labels
  _UpperCamelCase      :	Optional[Any]					      =  scope
  _UpperCamelCase      :	Optional[Any]					      =  len(lowerCAmelCase__   )
  _UpperCamelCase      :	Dict					      =  out_features
  _UpperCamelCase      :	str					      =  out_indices






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	int					      =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

  _UpperCamelCase      :	Union[str, Any]					      =  None
  if self.use_labels:
   _UpperCamelCase      :	Union[str, Any]					      =  ids_tensor([self.batch_size]					,     self.num_labels   )

  _UpperCamelCase      :	Any					      =  self.get_config()

  return config, pixel_values, labels






 def lowercase_      (self   ):

  '''simple docstring'''







  return ResNetConfig(
      num_channels=self.num_channels					,     embeddings_size=self.embeddings_size					,     hidden_sizes=self.hidden_sizes					,     depths=self.depths					,     hidden_act=self.hidden_act					,     num_labels=self.num_labels					,     out_features=self.out_features					,     out_indices=self.out_indices					,     )






 def lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	Dict					      =  ResNetModel(config=lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	str					      =  model(lowerCAmelCase__   )
  # expected last hidden states: B, C, H // 32, W // 32
  self.parent.assertEqual(
      result.last_hidden_state.shape					,     (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)					,     )






 def lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	List[Any]					      =  self.num_labels
  _UpperCamelCase      :	Tuple					      =  ResNetForImageClassification(lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	Optional[int]					      =  model(lowerCAmelCase__					,     labels=lowerCAmelCase__   )
  self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_labels)   )






 def lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	Union[str, Any]					      =  ResNetBackbone(config=lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	Optional[int]					      =  model(lowerCAmelCase__   )

  # verify feature maps
  self.parent.assertEqual(len(result.feature_maps   )					,     len(config.out_features   )   )
  self.parent.assertListEqual(list(result.feature_maps[0].shape   )					,     [self.batch_size, self.hidden_sizes[1], 4, 4]   )

  # verify channels
  self.parent.assertEqual(len(model.channels   )					,     len(config.out_features   )   )
  self.parent.assertListEqual(model.channels					,     config.hidden_sizes[1:]   )

  # verify backbone works with out_features=None
  _UpperCamelCase      :	Union[str, Any]					      =  None
  _UpperCamelCase      :	Optional[Any]					      =  ResNetBackbone(config=lowerCAmelCase__   )
  model.to(lowerCAmelCase__   )
  model.eval()
  _UpperCamelCase      :	Union[str, Any]					      =  model(lowerCAmelCase__   )

  # verify feature maps
  self.parent.assertEqual(len(result.feature_maps   )					,     1   )
  self.parent.assertListEqual(list(result.feature_maps[0].shape   )					,     [self.batch_size, self.hidden_sizes[-1], 1, 1]   )

  # verify channels
  self.parent.assertEqual(len(model.channels   )					,     1   )
  self.parent.assertListEqual(model.channels					,     [config.hidden_sizes[-1]]   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Dict					      =  self.prepare_config_and_inputs()
  _UpperCamelCase      ,	_UpperCamelCase      ,	_UpperCamelCase      :	Union[str, Any]					      =  config_and_inputs
  _UpperCamelCase      :	List[str]					      =  {"pixel_values": pixel_values}
  return config, inputs_dict







@require_torch
class  _SCREAMING_SNAKE_CASE       (     A__			,				A__			,				unittest.TestCase				):



 '''simple docstring'''





 __UpperCAmelCase		   =							(
     (
         ResNetModel,
         ResNetForImageClassification,
         ResNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 __UpperCAmelCase		   =							(
     {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
     if is_torch_available()
     else {}
 )

 __UpperCAmelCase		   =							True
 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							False






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	int					      =  ResNetModelTester(self   )
  _UpperCamelCase      :	List[Any]					      =  ConfigTester(self					,     config_class=lowerCAmelCase__					,     has_text_modality=lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  self.create_and_test_config_common_properties()
  self.config_tester.create_and_test_config_to_json_string()
  self.config_tester.create_and_test_config_to_json_file()
  self.config_tester.create_and_test_config_from_and_save_pretrained()
  self.config_tester.create_and_test_config_with_num_labels()
  self.config_tester.check_config_can_be_init_without_params()
  self.config_tester.check_config_arguments_init()






 def lowercase_      (self   ):

  '''simple docstring'''







  return






 @unittest.skip(reason="ResNet does not use inputs_embeds"   )
 def lowercase_      (self   ):

  '''simple docstring'''







  pass






 @unittest.skip(reason="ResNet does not support input and output embeddings"   )
 def lowercase_      (self   ):

  '''simple docstring'''







  pass






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      ,	_UpperCamelCase      :	Optional[int]					      =  self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   _UpperCamelCase      :	Optional[Any]					      =  model_class(lowerCAmelCase__   )
   _UpperCamelCase      :	Optional[Any]					      =  inspect.signature(model.forward   )
   # signature.parameters is an OrderedDict => so arg_names order is deterministic
   _UpperCamelCase      :	List[Any]					      =  [*signature.parameters.keys()]

   _UpperCamelCase      :	Tuple					      =  ["pixel_values"]
   self.assertListEqual(arg_names[:1]					,     lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Optional[int]					      =  self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_model(*lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	int					      =  self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_backbone(*lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      ,	_UpperCamelCase      :	Dict					      =  self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   _UpperCamelCase      :	List[Any]					      =  model_class(config=lowerCAmelCase__   )
   for name, module in model.named_modules():
    if isinstance(lowerCAmelCase__					,     (nn.BatchNormad, nn.GroupNorm)   ):
     self.assertTrue(
         torch.all(module.weight == 1   )					,     msg=F"Parameter {name} of model {model_class} seems not properly initialized"					,     )
     self.assertTrue(
         torch.all(module.bias == 0   )					,     msg=F"Parameter {name} of model {model_class} seems not properly initialized"					,     )






 def lowercase_      (self   ):

  '''simple docstring'''







  def check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   ):
   _UpperCamelCase      :	str					      =  model_class(lowerCAmelCase__   )
   model.to(lowerCAmelCase__   )
   model.eval()

   with torch.no_grad():
    _UpperCamelCase      :	List[Any]					      =  model(**self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__   )   )

   _UpperCamelCase      :	Tuple					      =  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

   _UpperCamelCase      :	str					      =  self.model_tester.num_stages
   self.assertEqual(len(lowerCAmelCase__   )					,     expected_num_stages + 1   )

   # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
   self.assertListEqual(
       list(hidden_states[0].shape[-2:]   )					,     [self.model_tester.image_size // 4, self.model_tester.image_size // 4]					,     )

  _UpperCamelCase      ,	_UpperCamelCase      :	Any					      =  self.model_tester.prepare_config_and_inputs_for_common()
  _UpperCamelCase      :	Optional[int]					      =  ["basic", "bottleneck"]
  for model_class in self.all_model_classes:
   for layer_type in layers_type:
    _UpperCamelCase      :	str					      =  layer_type
    _UpperCamelCase      :	List[Any]					      =  True
    check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   )

    # check that output_hidden_states also work using config
    del inputs_dict["output_hidden_states"]
    _UpperCamelCase      :	List[str]					      =  True

    check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__   )






 @unittest.skip(reason="ResNet does not use feedforward chunking"   )
 def lowercase_      (self   ):

  '''simple docstring'''







  pass






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Any					      =  self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__   )






 @slow
 def lowercase_      (self   ):

  '''simple docstring'''







  for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
   _UpperCamelCase      :	Optional[Any]					      =  ResNetModel.from_pretrained(lowerCAmelCase__   )
   self.assertIsNotNone(lowerCAmelCase__   )






def 				__lowerCAmelCase					(					)    ->       int:
 _UpperCamelCase      :	Union[str, Any]					      =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
 return image







@require_torch
@require_vision
class  _SCREAMING_SNAKE_CASE       (     unittest.TestCase				):



 '''simple docstring'''





 @cached_property
 def lowercase_      (self   ):

  '''simple docstring'''







  return (
      AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
      if is_vision_available()
      else None
  )






 @slow
 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	List[str]					      =  ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(lowerCAmelCase__   )

  _UpperCamelCase      :	Dict					      =  self.default_image_processor
  _UpperCamelCase      :	Dict					      =  prepare_img()
  _UpperCamelCase      :	str					      =  image_processor(images=lowerCAmelCase__					,     return_tensors="pt"   ).to(lowerCAmelCase__   )

  # forward pass
  with torch.no_grad():
   _UpperCamelCase      :	Optional[Any]					      =  model(**lowerCAmelCase__   )

  # verify the logits
  _UpperCamelCase      :	List[str]					      =  torch.Size((1, 10_00)   )
  self.assertEqual(outputs.logits.shape					,     lowerCAmelCase__   )

  _UpperCamelCase      :	Dict					      =  torch.tensor([-11.10_69, -9.7877, -8.3777]   ).to(lowerCAmelCase__   )

  self.assertTrue(torch.allclose(outputs.logits[0, :3]					,     lowerCAmelCase__					,     atol=1E-4   )   )







@require_torch
class  _SCREAMING_SNAKE_CASE       (     A__			,				unittest.TestCase				):



 '''simple docstring'''





 __UpperCAmelCase		   =							(ResNetBackbone,) if is_torch_available() else ()
 __UpperCAmelCase		   =							False
 __UpperCAmelCase		   =							ResNetConfig






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Any					      =  ResNetModelTester(self   )





'''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.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class 		snake_case_       (						unittest.TestCase						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







   @property
   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      1
          lowerCamelCase__				   =      3
          lowerCamelCase__				   =      (32, 32)

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







   @property
   def     __UpperCAmelCase      ( self):
          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     __UpperCAmelCase      ( self):
          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     __UpperCAmelCase      ( self):
          torch.manual_seed(0)
          lowerCamelCase__				   =      CLIPTextConfig(
              bos_token_id=0			,   eos_token_id=2			,   hidden_size=32			,   intermediate_size=37			,   layer_norm_eps=1E-0_5			,   num_attention_heads=4			,   num_hidden_layers=5			,   pad_token_id=1			,   vocab_size=10_00			,   )
          return CLIPTextModel(UpperCamelCase)







   @property
   def     __UpperCAmelCase      ( self):
          def extract(*UpperCamelCase			,   **UpperCamelCase):







                 class 		snake_case_       :



                    """simple docstring"""





                    def __init__( self):
                           lowerCamelCase__				   =      torch.ones([0])







                    def     __UpperCAmelCase      ( self			,   UpperCamelCase):
                           self.pixel_values.to(UpperCamelCase)
                           return self






                 return Out()

          return extract







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__				   =      self.dummy_cond_unet
          lowerCamelCase__				   =      DDIMScheduler(
              beta_start=0.0_0_0_8_5			,   beta_end=0.0_1_2			,   beta_schedule="scaled_linear"			,   clip_sample=UpperCamelCase			,   set_alpha_to_one=UpperCamelCase			,   )

          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=UpperCamelCase			,   scheduler=UpperCamelCase			,   vae=UpperCamelCase			,   text_encoder=UpperCamelCase			,   tokenizer=UpperCamelCase			,   safety_checker=UpperCamelCase			,   feature_extractor=self.dummy_extractor			,   )
          lowerCamelCase__				   =      sd_pipe.to(UpperCamelCase)
          sd_pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "A painting of a squirrel eating a burger"

          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe([prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np")
          lowerCamelCase__				   =      output.images

          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np"			,   return_dict=UpperCamelCase			,   )[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_7_5_3, 0.6_1_1_4, 0.5_0_0_1, 0.5_0_3_4, 0.5_4_7_0, 0.4_7_2_9, 0.4_9_7_1, 0.4_8_6_7, 0.4_8_6_7])

          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     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cpu"  # ensure determinism for the device-dependent torch.Generator
          lowerCamelCase__				   =      self.dummy_cond_unet
          lowerCamelCase__				   =      PNDMScheduler(skip_prk_steps=UpperCamelCase)
          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=UpperCamelCase			,   scheduler=UpperCamelCase			,   vae=UpperCamelCase			,   text_encoder=UpperCamelCase			,   tokenizer=UpperCamelCase			,   safety_checker=UpperCamelCase			,   feature_extractor=self.dummy_extractor			,   )
          lowerCamelCase__				   =      sd_pipe.to(UpperCamelCase)
          sd_pipe.set_progress_bar_config(disable=UpperCamelCase)

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

          lowerCamelCase__				   =      output.images

          lowerCamelCase__				   =      torch.Generator(device=UpperCamelCase).manual_seed(0)
          lowerCamelCase__				   =      sd_pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type="np"			,   return_dict=UpperCamelCase			,   )[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_1_2_2, 0.5_7_1_2, 0.4_8_2_5, 0.5_0_5_3, 0.5_6_4_6, 0.4_7_6_9, 0.5_1_7_9, 0.4_8_9_4, 0.4_9_9_4])

          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     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained(
              "hf-internal-testing/tiny-stable-diffusion-lms-pipe"			,   safety_checker=UpperCamelCase)
          assert isinstance(UpperCamelCase			,   UpperCamelCase)
          assert isinstance(pipe.scheduler			,   UpperCamelCase)
          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(UpperCamelCase)
                 lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained(UpperCamelCase)

          # 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     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      self.dummy_cond_unet
          lowerCamelCase__				   =      PNDMScheduler(skip_prk_steps=UpperCamelCase)
          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=UpperCamelCase			,   scheduler=UpperCamelCase			,   vae=UpperCamelCase			,   text_encoder=UpperCamelCase			,   tokenizer=UpperCamelCase			,   safety_checker=UpperCamelCase			,   feature_extractor=self.dummy_extractor			,   )
          lowerCamelCase__				   =      sd_pipe.to(UpperCamelCase)
          sd_pipe.set_progress_bar_config(disable=UpperCamelCase)

          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						):



   """simple docstring"""





   def     __UpperCAmelCase      ( self):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "a photo of a cat"
          lowerCamelCase__				   =      {
              "editing_prompt": ["sunglasses"],
              "reverse_editing_direction": [False],
              "edit_warmup_steps": 10,
              "edit_guidance_scale": 6,
              "edit_threshold": 0.9_5,
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      3
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.3_4_6_7_3_1_1_3,
              0.3_8_4_9_2_7_3_3,
              0.3_7_5_9_7_3_5_2,
              0.3_4_0_8_6_3_3_5,
              0.3_5_6_5_0_7_4_8,
              0.3_5_5_7_9_2_0_5,
              0.3_3_8_4_7_6_3,
              0.3_4_3_4_0_2_3_6,
              0.3_5_7_3_2_7_1,
          ]

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

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

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.4_1_8_8_7_8_2_6,
              0.3_7_7_2_8_7_6_6,
              0.3_0_1_3_8_2_7_2,
              0.4_1_4_1_6_3_3_5,
              0.4_1_6_6_4_9_8_5,
              0.3_6_2_8_3_3_9_2,
              0.3_6_1_9_1_2_4_6,
              0.4_3_3_6_4_4_6_5,
              0.4_3_0_0_1_7_3_2,
          ]

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

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







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "an image of a crowded boulevard, realistic, 4k"
          lowerCamelCase__				   =      {
              "editing_prompt": "crowd, crowded, people",
              "reverse_editing_direction": True,
              "edit_warmup_steps": 10,
              "edit_guidance_scale": 8.3,
              "edit_threshold": 0.9,
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      9
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.4_3_4_9_7_9_9_8,
              0.9_1_8_1_4_0_6_5,
              0.7_5_4_0_7_3_9,
              0.5_5_5_8_0_2_0_5,
              0.8_4_6_7_2_6_5,
              0.5_3_8_9_6_9_1,
              0.6_2_5_7_4_5_0_6,
              0.5_8_8_9_7_7_6_3,
              0.5_0_9_2_6_7_5_7,
          ]

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

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

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.3_0_8_9_7_1_9,
              0.3_0_5_0_0_1_4_4,
              0.2_9_0_1_6_0_4_2,
              0.3_0_6_3_0_9_6_4,
              0.3_2_5_6_8_7,
              0.2_9_4_1_9_2_2_5,
              0.2_9_0_8_0_9_1,
              0.2_8_7_2_3_5_9_8,
              0.2_7_6_9_6_2_9_4,
          ]

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

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







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "a castle next to a river"
          lowerCamelCase__				   =      {
              "editing_prompt": ["boat on a river, boat", "monet, impression, sunrise"],
              "reverse_editing_direction": False,
              "edit_warmup_steps": [15, 18],
              "edit_guidance_scale": 6,
              "edit_threshold": [0.9, 0.8],
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      48
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.7_5_1_6_3_5_5_5,
              0.7_6_0_3_7_1_4_5,
              0.6_1_7_8_5,
              0.9_1_8_9_6_7_3,
              0.8_6_2_7_7_0_1,
              0.8_5_1_8_9_6_9_4,
              0.8_5_1_2_8_1_3,
              0.8_7_0_1_2_0_7_6,
              0.8_3_1_2_8_5_7,
          ]

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

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

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.7_3_5_5_3_3_6_5,
              0.7_5_3_7_2_7_1,
              0.7_4_3_4_1_9_0_5,
              0.6_6_4_8_0_3_5_6,
              0.6_4_7_2_9_2_5,
              0.6_3_0_3_9_4_1_6,
              0.6_4_8_1_2_9_0_5,
              0.6_7_4_9_7_1_7,
              0.6_5_1_7_1_0_2,
          ]

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

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







   def     __UpperCAmelCase      ( self):
          lowerCamelCase__				   =      "cuda"
          lowerCamelCase__				   =      StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"			,   torch_dtype=torch.floataa)
          lowerCamelCase__				   =      pipe.to(UpperCamelCase)
          pipe.set_progress_bar_config(disable=UpperCamelCase)

          lowerCamelCase__				   =      "a photo of a cat"
          lowerCamelCase__				   =      {
              "editing_prompt": ["sunglasses"],
              "reverse_editing_direction": [False],
              "edit_warmup_steps": 10,
              "edit_guidance_scale": 6,
              "edit_threshold": 0.9_5,
              "edit_momentum_scale": 0.5,
              "edit_mom_beta": 0.6,
          }

          lowerCamelCase__				   =      3
          lowerCamelCase__				   =      7

          # no sega enabled
          lowerCamelCase__				   =      torch.Generator(UpperCamelCase)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.3_4_8_8_7_6_9_5,
              0.3_8_7_6_9_5_3,
              0.3_7_5,
              0.3_4_4_2_3_8_2_8,
              0.3_5_8_1_5_4_3,
              0.3_5_7_1_7_7_7_3,
              0.3_3_8_3_7_8_9,
              0.3_4_5_7_0_3_1_2,
              0.3_5_9_3_7_5,
          ]

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

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

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(UpperCamelCase)
          lowerCamelCase__				   =      pipe(
              [prompt]			,   generator=UpperCamelCase			,   guidance_scale=UpperCamelCase			,   num_inference_steps=50			,   output_type="np"			,   width=5_12			,   height=5_12			,   **UpperCamelCase			,   )

          lowerCamelCase__				   =      output.images
          lowerCamelCase__				   =      image[0, -3:, -3:, -1]
          lowerCamelCase__				   =      [
              0.4_2_2_8_5_1_5_6,
              0.3_6_9_1_4_0_6_2,
              0.2_9_0_7_7_1_4_8,
              0.4_2_0_4_1_0_1_6,
              0.4_1_9_1_8_9_4_5,
              0.3_5_4_9_8_0_4_7,
              0.3_6_1_8_1_6_4,
              0.4_4_2_3_8_2_8,
              0.4_3_1_1_5_2_3_4,
          ]

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

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

