


'''simple docstring'''





import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel





def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	Tuple:


						'''simple docstring'''






						if "img_encoder.pos_embed" in name:
												__snake_case				=		name.replace("img_encoder.pos_embed"      ,	"vision_model.embeddings.position_embeddings" )
						if "img_encoder.patch_embed.proj" in name:
												__snake_case				=		name.replace("img_encoder.patch_embed.proj"      ,	"vision_model.embeddings.patch_embeddings.projection" )
						if "img_encoder.patch_embed.norm" in name:
												__snake_case				=		name.replace("img_encoder.patch_embed.norm"      ,	"vision_model.embeddings.layernorm" )
						if "img_encoder.layers" in name:
												__snake_case				=		name.replace("img_encoder.layers"      ,	"vision_model.encoder.stages" )
						if "blocks" in name and "res" not in name:
												__snake_case				=		name.replace("blocks"      ,	"layers" )
						if "attn" in name and "pre_assign" not in name:
												__snake_case				=		name.replace("attn"      ,	"self_attn" )
						if "proj" in name and "self_attn" in name and "text" not in name:
												__snake_case				=		name.replace("proj"      ,	"out_proj" )
						if "pre_assign_attn.attn.proj" in name:
												__snake_case				=		name.replace("pre_assign_attn.attn.proj"      ,	"pre_assign_attn.attn.out_proj" )
						if "norm1" in name:
												__snake_case				=		name.replace("norm1"      ,	"layer_norm1" )
						if "norm2" in name and "pre_assign" not in name:
												__snake_case				=		name.replace("norm2"      ,	"layer_norm2" )
						if "img_encoder.norm" in name:
												__snake_case				=		name.replace("img_encoder.norm"      ,	"vision_model.layernorm" )
						# text encoder
						if "text_encoder.token_embedding" in name:
												__snake_case				=		name.replace("text_encoder.token_embedding"      ,	"text_model.embeddings.token_embedding" )
						if "text_encoder.positional_embedding" in name:
												__snake_case				=		name.replace("text_encoder.positional_embedding"      ,	"text_model.embeddings.position_embedding.weight" )
						if "text_encoder.transformer.resblocks." in name:
												__snake_case				=		name.replace("text_encoder.transformer.resblocks."      ,	"text_model.encoder.layers." )
						if "ln_1" in name:
												__snake_case				=		name.replace("ln_1"      ,	"layer_norm1" )
						if "ln_2" in name:
												__snake_case				=		name.replace("ln_2"      ,	"layer_norm2" )
						if "c_fc" in name:
												__snake_case				=		name.replace("c_fc"      ,	"fc1" )
						if "c_proj" in name:
												__snake_case				=		name.replace("c_proj"      ,	"fc2" )
						if "text_encoder" in name:
												__snake_case				=		name.replace("text_encoder"      ,	"text_model" )
						if "ln_final" in name:
												__snake_case				=		name.replace("ln_final"      ,	"final_layer_norm" )
						# projection layers
						if "img_projector.linear_hidden." in name:
												__snake_case				=		name.replace("img_projector.linear_hidden."      ,	"visual_projection." )
						if "img_projector.linear_out." in name:
												__snake_case				=		name.replace("img_projector.linear_out."      ,	"visual_projection.3." )
						if "text_projector.linear_hidden" in name:
												__snake_case				=		name.replace("text_projector.linear_hidden"      ,	"text_projection" )
						if "text_projector.linear_out" in name:
												__snake_case				=		name.replace("text_projector.linear_out"      ,	"text_projection.3" )

						return name





def 	_lowerCAmelCase       (    _lowerCAmelCase      ,	_lowerCAmelCase )						->	Any:


						'''simple docstring'''






						for key in orig_state_dict.copy().keys():
												__snake_case				=		orig_state_dict.pop(a_ )

												if "qkv" in key:
																		# weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment:
																		# we need to split them up into separate matrices/vectors
																		__snake_case				=		key.split("." )
																		__snake_case				=		int(key_split[2] ), int(key_split[4] )
																		__snake_case				=		config.vision_config.hidden_size
																		if "weight" in key:
																								__snake_case				=		val[:dim, :]
																								__snake_case				=		val[dim : dim * 2, :]
																								__snake_case				=		val[-dim:, :]
																		else:
																								__snake_case				=		val[:dim]
																								__snake_case				=		val[dim : dim * 2]
																								__snake_case				=		val[-dim:]
												elif "in_proj" in key:
																		# weights and biases of the key, value and query projections of text encoder's attention layers require special treatment:
																		# we need to split them up into separate matrices/vectors
																		__snake_case				=		key.split("." )
																		__snake_case				=		int(key_split[3] )
																		__snake_case				=		config.text_config.hidden_size
																		if "weight" in key:
																								__snake_case				=		val[:dim, :]
																								__snake_case				=		val[
																								    dim : dim * 2, :
																								]
																								__snake_case				=		val[-dim:, :]
																		else:
																								__snake_case				=		val[:dim]
																								__snake_case				=		val[dim : dim * 2]
																								__snake_case				=		val[-dim:]
												else:
																		__snake_case				=		rename_key(a_ )
																		# squeeze if necessary
																		if (
																		    "text_projection.0" in new_name
																		    or "text_projection.3" in new_name
																		    or "visual_projection.0" in new_name
																		    or "visual_projection.3" in new_name
																		):
																								__snake_case				=		val.squeeze_()
																		else:
																								__snake_case				=		val

						return orig_state_dict





def 	_lowerCAmelCase       (    )						->	List[Any]:


						'''simple docstring'''






						__snake_case				=		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
						__snake_case				=		Image.open(requests.get(a_      ,	stream=a_ ).raw )
						return im





@torch.no_grad()
def 	_lowerCAmelCase       (    _lowerCAmelCase      ,	_lowerCAmelCase      ,	_lowerCAmelCase="groupvit-gcc-yfcc"      ,	_lowerCAmelCase=False )						->	Any:


						'''simple docstring'''






						__snake_case				=		GroupViTConfig()
						__snake_case				=		GroupViTModel(a_ ).eval()

						__snake_case				=		torch.load(a_      ,	map_location="cpu" )['''model''']
						__snake_case				=		convert_state_dict(a_      ,	a_ )
						__snake_case				=		model.load_state_dict(a_      ,	strict=a_ )
						assert missing_keys == ["text_model.embeddings.position_ids"]
						assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(a_ ) == 0)

						# verify result
						__snake_case				=		CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32" )
						__snake_case				=		prepare_img()
						__snake_case				=		processor(text=["a photo of a cat", "a photo of a dog"]      ,	images=a_      ,	padding=a_      ,	return_tensors="pt" )

						with torch.no_grad():
												__snake_case				=		model(**a_ )

						if model_name == "groupvit-gcc-yfcc":
												__snake_case				=		torch.tensor([[13.35_23, 6.36_29]] )
						elif model_name == "groupvit-gcc-redcaps":
												__snake_case				=		torch.tensor([[16.18_73, 8.62_30]] )
						else:
												raise ValueError(F'''Model name {model_name} not supported.''' )
						assert torch.allclose(outputs.logits_per_image      ,	a_      ,	atol=1E-3 )

						processor.save_pretrained(a_ )
						model.save_pretrained(a_ )
						print("Successfully saved processor and model to"      ,	a_ )

						if push_to_hub:
												print("Pushing to the hub..." )
												processor.push_to_hub(a_      ,	organization="nielsr" )
												model.push_to_hub(a_      ,	organization="nielsr" )


if __name__ == "__main__":
	A							:					str     						=     argparse.ArgumentParser()
	parser.add_argument(
	    '--pytorch_dump_folder_path', default=None, type=str, help='Path to dump the processor and PyTorch model.'
	)
	parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to GroupViT checkpoint')
	parser.add_argument(
	    '--model_name',
	    default='groupvit-gccy-fcc',
	    type=str,
	    help='Name of the model. Expecting either \'groupvit-gcc-yfcc\' or \'groupvit-gcc-redcaps\'',
	)
	parser.add_argument(
	    '--push_to_hub',
	    action='store_true',
	    help='Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.',
	)
	A							:					Union[str, Any]     						=     parser.parse_args()

	convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)









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





