





import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 transformers import ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
     from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor

class      A       :



      def __init__(	self:						Any		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						Union[str, Any]=13		,  _lowerCAmelCase:						Union[str, Any]=32		,  _lowerCAmelCase:						List[Any]=3		,  _lowerCAmelCase:						Union[str, Any]=4		,  _lowerCAmelCase:						Optional[Any]=[10, 20, 30, 40]		,  _lowerCAmelCase:						Any=[2, 2, 3, 2]		,  _lowerCAmelCase:						List[str]=True		,  _lowerCAmelCase:						Optional[Any]=True		,  _lowerCAmelCase:						int=37		,  _lowerCAmelCase:						str="gelu"		,  _lowerCAmelCase:						int=10		,  _lowerCAmelCase:						List[str]=0.02		,  _lowerCAmelCase:						int=["stage2", "stage3", "stage4"]		,  _lowerCAmelCase:						List[str]=[2, 3, 4]		,  _lowerCAmelCase:						Any=None		,  )						->    List[Any]:
         '''simple docstring'''

         UpperCAmelCase_											=parent
         UpperCAmelCase_											=batch_size
         UpperCAmelCase_											=image_size
         UpperCAmelCase_											=num_channels
         UpperCAmelCase_											=num_stages
         UpperCAmelCase_											=hidden_sizes
         UpperCAmelCase_											=depths
         UpperCAmelCase_											=is_training
         UpperCAmelCase_											=use_labels
         UpperCAmelCase_											=intermediate_size
         UpperCAmelCase_											=hidden_act
         UpperCAmelCase_											=num_labels
         UpperCAmelCase_											=initializer_range
         UpperCAmelCase_											=out_features
         UpperCAmelCase_											=out_indices
         UpperCAmelCase_											=scope



      def 	lowerCAmelCase__    (	self:						Any       )						->    str:
         '''simple docstring'''

         UpperCAmelCase_											=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

         UpperCAmelCase_											=None
         if self.use_labels:
            UpperCAmelCase_											=ids_tensor([self.batch_size]		,  self.num_labels       )

         UpperCAmelCase_											=self.get_config()

         return config, pixel_values, labels



      def 	lowerCAmelCase__    (	self:						Union[str, Any]       )						->    Any:
         '''simple docstring'''

         return ConvNextVaConfig(
             num_channels=self.num_channels		,  hidden_sizes=self.hidden_sizes		,  depths=self.depths		,  num_stages=self.num_stages		,  hidden_act=self.hidden_act		,  is_decoder=_lowerCAmelCase		,  initializer_range=self.initializer_range		,  out_features=self.out_features		,  out_indices=self.out_indices		,  num_labels=self.num_labels		,  )



      def 	lowerCAmelCase__    (	self:						Union[str, Any]		,  _lowerCAmelCase:						int		,  _lowerCAmelCase:						Union[str, Any]		,  _lowerCAmelCase:						List[Any]       )						->    Optional[int]:
         '''simple docstring'''

         UpperCAmelCase_											=ConvNextVaModel(config=_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=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 	lowerCAmelCase__    (	self:						str		,  _lowerCAmelCase:						Union[str, Any]		,  _lowerCAmelCase:						Tuple		,  _lowerCAmelCase:						Dict       )						->    Any:
         '''simple docstring'''

         UpperCAmelCase_											=ConvNextVaForImageClassification(_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase		,  labels=_lowerCAmelCase       )
         self.parent.assertEqual(result.logits.shape		,  (self.batch_size, self.num_labels)       )



      def 	lowerCAmelCase__    (	self:						str		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						List[Any]		,  _lowerCAmelCase:						Union[str, Any]       )						->    List[Any]:
         '''simple docstring'''

         UpperCAmelCase_											=ConvNextVaBackbone(config=_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=model(_lowerCAmelCase       )

         # verify hidden states
         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_											=None
         UpperCAmelCase_											=ConvNextVaBackbone(config=_lowerCAmelCase       )
         model.to(_lowerCAmelCase       )
         model.eval()
         UpperCAmelCase_											=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 	lowerCAmelCase__    (	self:						str       )						->    str:
         '''simple docstring'''

         UpperCAmelCase_											=self.prepare_config_and_inputs()
         UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_											=config_and_inputs
         UpperCAmelCase_											={"pixel_values": pixel_values}
         return config, inputs_dict






      def 	lowerCAmelCase__    (	self:						Union[str, Any]       )						->    List[Any]:
         '''simple docstring'''

         UpperCAmelCase_											=self.prepare_config_and_inputs()
         UpperCAmelCase_						,       UpperCAmelCase_						,       UpperCAmelCase_											=config_and_inputs
         UpperCAmelCase_											={"pixel_values": pixel_values, "labels": labels}
         return config, inputs_dict

@require_torch
class      A       (	__lowercase		,      __lowercase		,      unittest.TestCase						):
      _snake_case							     =(
          (
              ConvNextVaModel,
              ConvNextVaForImageClassification,
              ConvNextVaBackbone,
          )
          if is_torch_available()
          else ()
      )
      _snake_case							     =(
          {'''feature-extraction''': ConvNextVaModel, '''image-classification''': ConvNextVaForImageClassification}
          if is_torch_available()
          else {}
      )

      _snake_case							     =False
      _snake_case							     =False
      _snake_case							     =False
      _snake_case							     =False
      _snake_case							     =False



      def 	lowerCAmelCase__    (	self:						Optional[Any]       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_											=ConvNextVaModelTester(self       )
         UpperCAmelCase_											=ConfigTester(self		,  config_class=_lowerCAmelCase		,  has_text_modality=_lowerCAmelCase		,  hidden_size=37       )



      def 	lowerCAmelCase__    (	self:						str       )						->    Tuple:
         '''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 	lowerCAmelCase__    (	self:						Optional[Any]       )						->    Any:
         '''simple docstring'''

         return



      @unittest.skip(reason="ConvNextV2 does not use inputs_embeds"       )
      def 	lowerCAmelCase__    (	self:						Dict       )						->    Any:
         '''simple docstring'''

         pass



      @unittest.skip(reason="ConvNextV2 does not support input and output embeddings"       )
      def 	lowerCAmelCase__    (	self:						List[str]       )						->    Tuple:
         '''simple docstring'''

         pass



      @unittest.skip(reason="ConvNextV2 does not use feedforward chunking"       )
      def 	lowerCAmelCase__    (	self:						int       )						->    Optional[int]:
         '''simple docstring'''

         pass



      def 	lowerCAmelCase__    (	self:						List[str]       )						->    Dict:
         '''simple docstring'''

         if not self.model_tester.is_training:
            return

         for model_class in self.all_model_classes:
            UpperCAmelCase_						,       UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs_with_labels()
            UpperCAmelCase_											=True

            if model_class.__name__ in [
                *get_values(_lowerCAmelCase       ),
                *get_values(_lowerCAmelCase       ),
            ]:
               continue

            UpperCAmelCase_											=model_class(_lowerCAmelCase       )
            model.to(_lowerCAmelCase       )
            model.train()
            UpperCAmelCase_											=self._prepare_for_class(_lowerCAmelCase		,  _lowerCAmelCase		,  return_labels=_lowerCAmelCase       )
            UpperCAmelCase_											=model(**_lowerCAmelCase       ).loss
            loss.backward()



      def 	lowerCAmelCase__    (	self:						Union[str, Any]       )						->    List[Any]:
         '''simple docstring'''

         if not self.model_tester.is_training:
            return

         for model_class in self.all_model_classes:
            UpperCAmelCase_						,       UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs_with_labels()
            UpperCAmelCase_											=False
            UpperCAmelCase_											=True

            if (
                model_class.__name__
                in [*get_values(_lowerCAmelCase       ), *get_values(_lowerCAmelCase       )]
                or not model_class.supports_gradient_checkpointing
            ):
               continue

            UpperCAmelCase_											=model_class(_lowerCAmelCase       )
            model.to(_lowerCAmelCase       )
            model.gradient_checkpointing_enable()
            model.train()
            UpperCAmelCase_											=self._prepare_for_class(_lowerCAmelCase		,  _lowerCAmelCase		,  return_labels=_lowerCAmelCase       )
            UpperCAmelCase_											=model(**_lowerCAmelCase       ).loss
            loss.backward()



      def 	lowerCAmelCase__    (	self:						Tuple       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_						,       UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs_for_common()

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

            UpperCAmelCase_											=["pixel_values"]
            self.assertListEqual(arg_names[:1]		,  _lowerCAmelCase       )



      def 	lowerCAmelCase__    (	self:						Dict       )						->    List[Any]:
         '''simple docstring'''

         UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase       )



      def 	lowerCAmelCase__    (	self:						List[Any]       )						->    Optional[int]:
         '''simple docstring'''

         def check_hidden_states_output(_lowerCAmelCase:						Optional[Any]		,  _lowerCAmelCase:						Any		,  _lowerCAmelCase:						Union[str, Any]       ):
            UpperCAmelCase_											=model_class(_lowerCAmelCase       )
            model.to(_lowerCAmelCase       )
            model.eval()

            with torch.no_grad():
               UpperCAmelCase_											=model(**self._prepare_for_class(_lowerCAmelCase		,  _lowerCAmelCase       )       )

            UpperCAmelCase_											=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

            UpperCAmelCase_											=self.model_tester.num_stages
            self.assertEqual(len(_lowerCAmelCase       )		,  expected_num_stages + 1       )

            # ConvNextV2'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_											=self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase_											=True
            check_hidden_states_output(_lowerCAmelCase		,  _lowerCAmelCase		,  _lowerCAmelCase       )

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            UpperCAmelCase_											=True

            check_hidden_states_output(_lowerCAmelCase		,  _lowerCAmelCase		,  _lowerCAmelCase       )



      def 	lowerCAmelCase__    (	self:						Any       )						->    List[Any]:
         '''simple docstring'''

         UpperCAmelCase_											=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase       )






      @slow
      def 	lowerCAmelCase__    (	self:						Optional[int]       )						->    List[Any]:
         '''simple docstring'''

         for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase_											=ConvNextVaModel.from_pretrained(_lowerCAmelCase       )
            self.assertIsNotNone(_lowerCAmelCase       )




def     a__ (					):






   '''simple docstring'''






   UpperCAmelCase_											=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
   return image





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



      @cached_property
      def 	lowerCAmelCase__    (	self:						Union[str, Any]       )						->    Union[str, Any]:
         '''simple docstring'''

         return AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224"       ) if is_vision_available() else None






      @slow
      def 	lowerCAmelCase__    (	self:						Any       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_											=ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224"       ).to(_lowerCAmelCase       )

         UpperCAmelCase_											=self.default_image_processor
         UpperCAmelCase_											=prepare_img()
         UpperCAmelCase_											=preprocessor(images=_lowerCAmelCase		,  return_tensors="pt"       ).to(_lowerCAmelCase       )

         # forward pass
         with torch.no_grad():
            UpperCAmelCase_											=model(**_lowerCAmelCase       )

         # verify the logits
         UpperCAmelCase_											=torch.Size((1, 1000)       )
         self.assertEqual(outputs.logits.shape		,  _lowerCAmelCase       )

         UpperCAmelCase_											=torch.tensor([0.99_96, 0.19_66, -0.43_86]       ).to(_lowerCAmelCase       )
         self.assertTrue(torch.allclose(outputs.logits[0, :3]		,  _lowerCAmelCase		,  atol=1e-4       )       )











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



      def 	lowerCAmelCase__    (	self:						str       )						->    Optional[Any]:
         '''simple docstring'''

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



      @property
      def 	lowerCAmelCase__    (	self:						Optional[int]       )						->    List[str]:
         '''simple docstring'''

         UpperCAmelCase_											=1
         UpperCAmelCase_											=3
         UpperCAmelCase_											=(32, 32)

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



      @property
      def 	lowerCAmelCase__    (	self:						Any       )						->    Union[str, Any]:
         '''simple docstring'''

         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		,  )
         return model



      @property
      def 	lowerCAmelCase__    (	self:						List[Any]       )						->    int:
         '''simple docstring'''

         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		,  )
         return model



      @property
      def 	lowerCAmelCase__    (	self:						Dict       )						->    str:
         '''simple docstring'''

         torch.manual_seed(0       )
         UpperCAmelCase_											=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=1000		,  )
         return CLIPTextModel(_lowerCAmelCase       )



      @property
      def 	lowerCAmelCase__    (	self:						Optional[int]       )						->    Optional[Any]:
         '''simple docstring'''

         def extract(*_lowerCAmelCase:						List[str]		,  **_lowerCAmelCase:						List[str]       ):

            class      A       :



                  def __init__(	self:						List[str]       )						->    Any:
                     '''simple docstring'''

                     UpperCAmelCase_											=torch.ones([0]       )






                  def 	lowerCAmelCase__    (	self:						List[str]		,  _lowerCAmelCase:						Dict       )						->    List[Any]:
                     '''simple docstring'''

                     self.pixel_values.to(_lowerCAmelCase       )
                     return self

            return Out()

         return extract



      def 	lowerCAmelCase__    (	self:						Tuple       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_											="cpu"  # ensure determinism for the device-dependent torch.Generator
         UpperCAmelCase_											=self.dummy_cond_unet
         UpperCAmelCase_											=DDIMScheduler(
             beta_start=0.0_00_85		,  beta_end=0.0_12		,  beta_schedule="scaled_linear"		,  clip_sample=_lowerCAmelCase		,  set_alpha_to_one=_lowerCAmelCase		,  )

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

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

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

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

         UpperCAmelCase_											=torch.Generator(device=_lowerCAmelCase       ).manual_seed(0       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=6.0		,  num_inference_steps=2		,  output_type="np"		,  return_dict=_lowerCAmelCase		,  )[0]

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

         assert image.shape == (1, 64, 64, 3)
         UpperCAmelCase_											=np.array([0.57_56, 0.61_18, 0.50_05, 0.50_41, 0.54_71, 0.47_26, 0.49_76, 0.48_65, 0.48_64]       )

         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 	lowerCAmelCase__    (	self:						Optional[int]       )						->    List[Any]:
         '''simple docstring'''

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

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

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

         UpperCAmelCase_											=output.images

         UpperCAmelCase_											=torch.Generator(device=_lowerCAmelCase       ).manual_seed(0       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=6.0		,  num_inference_steps=2		,  output_type="np"		,  return_dict=_lowerCAmelCase		,  )[0]

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

         assert image.shape == (1, 64, 64, 3)
         UpperCAmelCase_											=np.array([0.51_25, 0.57_16, 0.48_28, 0.50_60, 0.56_50, 0.47_68, 0.51_85, 0.48_95, 0.49_93]       )

         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 	lowerCAmelCase__    (	self:						List[Any]       )						->    str:
         '''simple docstring'''

         UpperCAmelCase_											=StableDiffusionPipeline.from_pretrained(
             "hf-internal-testing/tiny-stable-diffusion-lms-pipe"		,  safety_checker=_lowerCAmelCase       )
         assert isinstance(_lowerCAmelCase		,  _lowerCAmelCase       )
         assert isinstance(pipe.scheduler		,  _lowerCAmelCase       )
         assert pipe.safety_checker is None

         UpperCAmelCase_											=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(_lowerCAmelCase       )
            UpperCAmelCase_											=StableDiffusionPipeline.from_pretrained(_lowerCAmelCase       )

         # sanity check that the pipeline still works
         assert pipe.safety_checker is None
         UpperCAmelCase_											=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 	lowerCAmelCase__    (	self:						int       )						->    Optional[int]:
         '''simple docstring'''

         UpperCAmelCase_											=self.dummy_cond_unet
         UpperCAmelCase_											=PNDMScheduler(skip_prk_steps=_lowerCAmelCase       )
         UpperCAmelCase_											=self.dummy_vae
         UpperCAmelCase_											=self.dummy_text_encoder
         UpperCAmelCase_											=CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

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

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

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

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

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



      def 	lowerCAmelCase__    (	self:						List[Any]       )						->    Tuple:
         '''simple docstring'''

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



      def 	lowerCAmelCase__    (	self:						Union[str, Any]       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_											=StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"		,  safety_checker=_lowerCAmelCase       )
         UpperCAmelCase_											=LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config       )
         UpperCAmelCase_											=sd_pipe.to(_lowerCAmelCase       )
         sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase       )

         UpperCAmelCase_											=(
             "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 "
         )
         UpperCAmelCase_											=40_0366_0346
         UpperCAmelCase_											=7

         # without safety guidance (sld_guidance_scale = 0)
         UpperCAmelCase_											=torch.manual_seed(_lowerCAmelCase       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=_lowerCAmelCase		,  num_inference_steps=50		,  output_type="np"		,  width=512		,  height=512		,  sld_guidance_scale=0		,  )

         UpperCAmelCase_											=output.images
         UpperCAmelCase_											=image[0, -3:, -3:, -1]
         UpperCAmelCase_											=[0.22_78, 0.22_31, 0.22_49, 0.23_33, 0.23_03, 0.18_85, 0.22_73, 0.21_44, 0.21_76]

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

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

         # without safety guidance (strong configuration)
         UpperCAmelCase_											=torch.manual_seed(_lowerCAmelCase       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=_lowerCAmelCase		,  num_inference_steps=50		,  output_type="np"		,  width=512		,  height=512		,  sld_guidance_scale=2000		,  sld_warmup_steps=7		,  sld_threshold=0.0_25		,  sld_momentum_scale=0.5		,  sld_mom_beta=0.7		,  )

         UpperCAmelCase_											=output.images
         UpperCAmelCase_											=image[0, -3:, -3:, -1]
         UpperCAmelCase_											=[0.23_83, 0.22_76, 0.2_36, 0.21_92, 0.21_86, 0.20_53, 0.19_71, 0.19_01, 0.17_19]

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

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



      def 	lowerCAmelCase__    (	self:						Any       )						->    Union[str, Any]:
         '''simple docstring'''

         UpperCAmelCase_											=StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"		,  safety_checker=_lowerCAmelCase       )
         UpperCAmelCase_											=LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config       )
         UpperCAmelCase_											=sd_pipe.to(_lowerCAmelCase       )
         sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase       )

         UpperCAmelCase_											="padme amidala taking a bath artwork, safe for work, no nudity"
         UpperCAmelCase_											=27_3497_1755
         UpperCAmelCase_											=7

         UpperCAmelCase_											=torch.manual_seed(_lowerCAmelCase       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=_lowerCAmelCase		,  num_inference_steps=50		,  output_type="np"		,  width=512		,  height=512		,  sld_guidance_scale=0		,  )

         UpperCAmelCase_											=output.images
         UpperCAmelCase_											=image[0, -3:, -3:, -1]
         UpperCAmelCase_											=[0.35_02, 0.36_22, 0.33_96, 0.36_42, 0.34_78, 0.33_18, 0.35, 0.33_48, 0.32_97]

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

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

         UpperCAmelCase_											=torch.manual_seed(_lowerCAmelCase       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=_lowerCAmelCase		,  num_inference_steps=50		,  output_type="np"		,  width=512		,  height=512		,  sld_guidance_scale=2000		,  sld_warmup_steps=7		,  sld_threshold=0.0_25		,  sld_momentum_scale=0.5		,  sld_mom_beta=0.7		,  )

         UpperCAmelCase_											=output.images
         UpperCAmelCase_											=image[0, -3:, -3:, -1]
         UpperCAmelCase_											=[0.55_31, 0.52_06, 0.48_95, 0.51_56, 0.51_82, 0.47_51, 0.48_02, 0.48_03, 0.44_43]

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

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






      def 	lowerCAmelCase__    (	self:						str       )						->    List[Any]:
         '''simple docstring'''

         UpperCAmelCase_											=StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"       )
         UpperCAmelCase_											=sd_pipe.to(_lowerCAmelCase       )
         sd_pipe.set_progress_bar_config(disable=_lowerCAmelCase       )

         UpperCAmelCase_											=(
             "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
             " leyendecker"
         )
         UpperCAmelCase_											=10_4435_5234
         UpperCAmelCase_											=12

         UpperCAmelCase_											=torch.manual_seed(_lowerCAmelCase       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=_lowerCAmelCase		,  num_inference_steps=50		,  output_type="np"		,  width=512		,  height=512		,  sld_guidance_scale=0		,  )

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

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

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

         UpperCAmelCase_											=torch.manual_seed(_lowerCAmelCase       )
         UpperCAmelCase_											=sd_pipe(
             [prompt]		,  generator=_lowerCAmelCase		,  guidance_scale=_lowerCAmelCase		,  num_inference_steps=50		,  output_type="np"		,  width=512		,  height=512		,  sld_guidance_scale=2000		,  sld_warmup_steps=7		,  sld_threshold=0.0_25		,  sld_momentum_scale=0.5		,  sld_mom_beta=0.7		,  )

         UpperCAmelCase_											=output.images
         UpperCAmelCase_											=image[0, -3:, -3:, -1]
         UpperCAmelCase_											=np.array([0.58_18, 0.62_85, 0.68_35, 0.60_19, 0.6_25, 0.67_54, 0.60_96, 0.63_34, 0.65_61]       )
         assert image.shape == (1, 512, 512, 3)

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




