


import gc
import unittest

from transformers import CTRLConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
	    CTRLForSequenceClassification,
	    CTRLLMHeadModel,
	    CTRLModel,
	)






class     UpperCamelCase:


					def __init__(						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Any=1_4     ,    SCREAMING_SNAKE_CASE	:		Any=7     ,    SCREAMING_SNAKE_CASE	:		Any=True     ,    SCREAMING_SNAKE_CASE	:		str=True     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=True     ,    SCREAMING_SNAKE_CASE	:		Tuple=True     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=True     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]=9_9     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]=3_2     ,    SCREAMING_SNAKE_CASE	:		List[str]=5     ,    SCREAMING_SNAKE_CASE	:		List[str]=4     ,    SCREAMING_SNAKE_CASE	:		List[str]=3_7     ,    SCREAMING_SNAKE_CASE	:		Any="gelu"     ,    SCREAMING_SNAKE_CASE	:		Tuple=0.1     ,    SCREAMING_SNAKE_CASE	:		List[str]=0.1     ,    SCREAMING_SNAKE_CASE	:		List[Any]=5_1_2     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=1_6     ,    SCREAMING_SNAKE_CASE	:		Optional[int]=2     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=0.02     ,    SCREAMING_SNAKE_CASE	:		int=3     ,    SCREAMING_SNAKE_CASE	:		Dict=4     ,    SCREAMING_SNAKE_CASE	:		Any=None     ,    )			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		parent
											__snake_case				=		batch_size
											__snake_case				=		seq_length
											__snake_case				=		is_training
											__snake_case				=		use_token_type_ids
											__snake_case				=		use_input_mask
											__snake_case				=		use_labels
											__snake_case				=		use_mc_token_ids
											__snake_case				=		vocab_size
											__snake_case				=		hidden_size
											__snake_case				=		num_hidden_layers
											__snake_case				=		num_attention_heads
											__snake_case				=		intermediate_size
											__snake_case				=		hidden_act
											__snake_case				=		hidden_dropout_prob
											__snake_case				=		attention_probs_dropout_prob
											__snake_case				=		max_position_embeddings
											__snake_case				=		type_vocab_size
											__snake_case				=		type_sequence_label_size
											__snake_case				=		initializer_range
											__snake_case				=		num_labels
											__snake_case				=		num_choices
											__snake_case				=		scope
											__snake_case				=		self.vocab_size - 1


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




											'''simple docstring'''

											__snake_case				=		ids_tensor([self.batch_size, self.seq_length]     ,    self.vocab_size						)

											__snake_case				=		None
											if self.use_input_mask:
																	__snake_case				=		random_attention_mask([self.batch_size, self.seq_length]						)

											__snake_case				=		None
											if self.use_token_type_ids:
																	__snake_case				=		ids_tensor([self.batch_size, self.seq_length]     ,    self.type_vocab_size						)

											__snake_case				=		None
											if self.use_mc_token_ids:
																	__snake_case				=		ids_tensor([self.batch_size, self.num_choices]     ,    self.seq_length						)

											__snake_case				=		None
											__snake_case				=		None
											__snake_case				=		None
											if self.use_labels:
																	__snake_case				=		ids_tensor([self.batch_size]     ,    self.type_sequence_label_size						)
																	__snake_case				=		ids_tensor([self.batch_size, self.seq_length]     ,    self.num_labels						)
																	__snake_case				=		ids_tensor([self.batch_size]     ,    self.num_choices						)

											__snake_case				=		self.get_config()

											__snake_case				=		ids_tensor([self.num_hidden_layers, self.num_attention_heads]     ,    2						)

											return (
											    config,
											    input_ids,
											    input_mask,
											    head_mask,
											    token_type_ids,
											    mc_token_ids,
											    sequence_labels,
											    token_labels,
											    choice_labels,
											)


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




											'''simple docstring'''

											return CTRLConfig(
											    vocab_size=self.vocab_size     ,    n_embd=self.hidden_size     ,    n_layer=self.num_hidden_layers     ,    n_head=self.num_attention_heads     ,    n_positions=self.max_position_embeddings     ,    pad_token_id=self.pad_token_id     ,    )


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Any     ,    SCREAMING_SNAKE_CASE	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		str     ,    SCREAMING_SNAKE_CASE	:		Dict     ,    *SCREAMING_SNAKE_CASE	:		Union[str, Any]						)			->	Any:




											'''simple docstring'''

											__snake_case				=		CTRLModel(config=SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()

											model(SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    head_mask=SCREAMING_SNAKE_CASE						)
											model(SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE						)
											__snake_case				=		model(SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.last_hidden_state.shape     ,    (self.batch_size, self.seq_length, self.hidden_size)						)
											self.parent.assertEqual(len(result.past_key_values						)     ,    config.n_layer						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		Dict     ,    SCREAMING_SNAKE_CASE	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		int     ,    *SCREAMING_SNAKE_CASE	:		Any						)			->	Tuple:




											'''simple docstring'''

											__snake_case				=		CTRLLMHeadModel(SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()

											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    labels=SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.loss.shape     ,    ()						)
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.seq_length, self.vocab_size)						)


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




											'''simple docstring'''

											__snake_case				=		self.prepare_config_and_inputs()

											(
											    (
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					(
											    __snake_case
											)		,					
											)				=		config_and_inputs

											__snake_case				=		{"input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask}

											return config, inputs_dict






					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Any     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		int     ,    *SCREAMING_SNAKE_CASE	:		List[Any]						)			->	str:




											'''simple docstring'''

											__snake_case				=		self.num_labels
											__snake_case				=		CTRLForSequenceClassification(SCREAMING_SNAKE_CASE						)
											model.to(SCREAMING_SNAKE_CASE						)
											model.eval()
											__snake_case				=		ids_tensor([self.batch_size]     ,    self.type_sequence_label_size						)
											__snake_case				=		model(SCREAMING_SNAKE_CASE     ,    token_type_ids=SCREAMING_SNAKE_CASE     ,    labels=SCREAMING_SNAKE_CASE						)
											self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.num_labels)						)






@require_torch
class     UpperCamelCase(  _a     ,							_a     ,							_a     ,							unittest.TestCase   ):
					snake_case_		:				Union[str, Any]										=	(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
					snake_case_		:				Any										=	(CTRLLMHeadModel,) if is_torch_available() else ()
					snake_case_		:				List[str]										=	(
					    {
					        """feature-extraction""": CTRLModel,
					        """text-classification""": CTRLForSequenceClassification,
					        """text-generation""": CTRLLMHeadModel,
					        """zero-shot""": CTRLForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					snake_case_		:				Union[str, Any]										=	True
					snake_case_		:				Union[str, Any]										=	False
					snake_case_		:				Tuple										=	False


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict     ,    SCREAMING_SNAKE_CASE	:		Dict     ,    SCREAMING_SNAKE_CASE	:		str     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		int     ,    SCREAMING_SNAKE_CASE	:		int						)			->	Dict:




											'''simple docstring'''

											if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
																	# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
																	# `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
																	# config could not be created.
																	return True

											return False


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	str:




											'''simple docstring'''

											__snake_case				=		CTRLModelTester(self						)
											__snake_case				=		ConfigTester(self     ,    config_class=SCREAMING_SNAKE_CASE     ,    n_embd=3_7						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	Optional[int]:




											'''simple docstring'''

											super().tearDown()
											# clean-up as much as possible GPU memory occupied by PyTorch
											gc.collect()
											torch.cuda.empty_cache()


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Tuple:




											'''simple docstring'''

											self.config_tester.run_common_tests()


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




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_ctrl_model(*SCREAMING_SNAKE_CASE						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	str:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_lm_head_model(*SCREAMING_SNAKE_CASE						)


					@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."						)
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	Optional[int]:




											'''simple docstring'''

											pass


					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	str:




											'''simple docstring'''

											for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	__snake_case				=		CTRLModel.from_pretrained(SCREAMING_SNAKE_CASE						)
																	self.assertIsNotNone(SCREAMING_SNAKE_CASE						)






					@unittest.skip("The model doesn't support left padding"						)  # and it's not used enough to be worth fixing :)
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Union[str, Any]						)			->	Optional[Any]:




											'''simple docstring'''

											pass






@require_torch
class     UpperCamelCase(  unittest.TestCase   ):


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]						)			->	Dict:




											'''simple docstring'''

											super().tearDown()
											# clean-up as much as possible GPU memory occupied by PyTorch
											gc.collect()
											torch.cuda.empty_cache()






					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	int:




											'''simple docstring'''

											__snake_case				=		CTRLLMHeadModel.from_pretrained("ctrl"						)
											model.to(SCREAMING_SNAKE_CASE						)
											__snake_case				=		torch.tensor(
											    [[1_1_8_5_9, 0, 1_6_1_1, 8]]     ,    dtype=torch.long     ,    device=SCREAMING_SNAKE_CASE						)  # Legal the president is
											__snake_case				=		[
											    1_1_8_5_9,
											    0,
											    1_6_1_1,
											    8,
											    5,
											    1_5_0,
											    2_6_4_4_9,
											    2,
											    1_9,
											    3_4_8,
											    4_6_9,
											    3,
											    2_5_9_5,
											    4_8,
											    2_0_7_4_0,
											    2_4_6_5_3_3,
											    2_4_6_5_3_3,
											    1_9,
											    3_0,
											    5,
											]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

											__snake_case				=		model.generate(SCREAMING_SNAKE_CASE     ,    do_sample=SCREAMING_SNAKE_CASE						)
											self.assertListEqual(output_ids[0].tolist()     ,    SCREAMING_SNAKE_CASE						)









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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		str						)			->	Dict:




											'''simple docstring'''

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


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		1
											__snake_case				=		3
											__snake_case				=		(3_2, 3_2)

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


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	Any:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)     ,    layers_per_block=2     ,    sample_size=3_2     ,    in_channels=4     ,    out_channels=4     ,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")     ,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")     ,    cross_attention_dim=3_2     ,    )
											return model


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	str:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		AutoencoderKL(
											    block_out_channels=[3_2, 6_4]     ,    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	:		List[str]						)			->	int:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		CLIPTextConfig(
											    bos_token_id=0     ,    eos_token_id=2     ,    hidden_size=3_2     ,    intermediate_size=3_7     ,    layer_norm_eps=1e-0_5     ,    num_attention_heads=4     ,    num_hidden_layers=5     ,    pad_token_id=1     ,    vocab_size=1_0_0_0     ,    )
											return CLIPTextModel(SCREAMING_SNAKE_CASE						)


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	str:




											'''simple docstring'''

											def extract(*SCREAMING_SNAKE_CASE	:		List[str]     ,    **SCREAMING_SNAKE_CASE	:		List[Any]						):






																	class     UpperCamelCase:


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




																												'''simple docstring'''

																												__snake_case				=		torch.ones([0]						)






																						def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]						)			->	List[Any]:




																												'''simple docstring'''

																												self.pixel_values.to(SCREAMING_SNAKE_CASE						)
																												return self




																	return Out()

											return extract


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Dict:




											'''simple docstring'''

											__snake_case				=		"cpu"  # ensure determinism for the device-dependent torch.Generator
											__snake_case				=		self.dummy_cond_unet
											__snake_case				=		DDIMScheduler(
											    beta_start=0.00085     ,    beta_end=0.012     ,    beta_schedule="scaled_linear"     ,    clip_sample=SCREAMING_SNAKE_CASE     ,    set_alpha_to_one=SCREAMING_SNAKE_CASE     ,    )

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

											# make sure here that pndm scheduler skips prk
											__snake_case				=		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     ,    )
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

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

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

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

											assert image.shape == (1, 6_4, 6_4, 3)
											__snake_case				=		np.array([0.5756, 0.6118, 0.5005, 0.5041, 0.5471, 0.4726, 0.4976, 0.4865, 0.4864]						)

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




											'''simple docstring'''

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

											# make sure here that pndm scheduler skips prk
											__snake_case				=		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     ,    )
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											__snake_case				=		output.images

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

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

											assert image.shape == (1, 6_4, 6_4, 3)
											__snake_case				=		np.array([0.5125, 0.5716, 0.4828, 0.5060, 0.5650, 0.4768, 0.5185, 0.4895, 0.4993]						)

											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	:		List[str]						)			->	List[Any]:




											'''simple docstring'''

											__snake_case				=		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

											__snake_case				=		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						)
																	__snake_case				=		StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE						)

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											__snake_case				=		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	:		Union[str, Any]						)			->	int:




											'''simple docstring'''

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

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

											# make sure here that pndm scheduler skips prk
											__snake_case				=		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     ,    )
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

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

											assert image.shape == (1, 6_4, 6_4, 3)






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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Tuple:




											'''simple docstring'''

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	Optional[Any]:




											'''simple docstring'''

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

											__snake_case				=		(
											    "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 "
											)
											__snake_case				=		4_0_0_3_6_6_0_3_4_6
											__snake_case				=		7

											# without safety guidance (sld_guidance_scale = 0)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

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

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

											# without safety guidance (strong configuration)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

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

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	List[str]:




											'''simple docstring'''

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

											__snake_case				=		"padme amidala taking a bath artwork, safe for work, no nudity"
											__snake_case				=		2_7_3_4_9_7_1_7_5_5
											__snake_case				=		7

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.3502, 0.3622, 0.3396, 0.3642, 0.3478, 0.3318, 0.35, 0.3348, 0.3297]

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

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

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		[0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

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

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






					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	int:




											'''simple docstring'''

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

											__snake_case				=		(
											    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
											    " leyendecker"
											)
											__snake_case				=		1_0_4_4_3_5_5_2_3_4
											__snake_case				=		1_2

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		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_1_2, 5_1_2, 3)

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

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

											__snake_case				=		output.images
											__snake_case				=		image[0, -3:, -3:, -1]
											__snake_case				=		np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]						)
											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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





