



import argparse
import os
import re

import numpy as np
import PIL
import torch
from timm import create_model
from torch.optim.lr_scheduler import OneCycleLR
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import Compose, RandomResizedCrop, Resize, ToTensor

from accelerate import Accelerator

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[str]    ):
				"""simple docstring"""







				__a       =		fname.split(os.path.sep    )[-1]
				return re.search(r"""^(.*)_\d+\.jpg$"""				,     _SCREAMING_SNAKE_CASE    ).groups()[0]






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):





							def __init__(   self		:		Union[str, Any]      ,				__lowercase		:		Any      ,				__lowercase		:		Optional[int]=None      ,				__lowercase		:		Any=None	):

											'''simple docstring'''
											__a       =		file_names
											__a       =		image_transform
											__a       =		label_to_id





							def __len__(   self		:		Any	):

											'''simple docstring'''
											return len(self.file_names	)







							def __getitem__(   self		:		Optional[Any]      ,				__lowercase		:		Any	):

											'''simple docstring'''
											__a       =		self.file_names[idx]
											__a       =		PIL.Image.open(__lowercase	)
											__a       =		raw_image.convert("""RGB"""	)
											if self.image_transform is not None:
															__a       =		self.image_transform(__lowercase	)
											__a       =		extract_label(__lowercase	)
											if self.label_to_id is not None:
															__a       =		self.label_to_id[label]
											return {"image": image, "label": label}



def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[str]				,     _SCREAMING_SNAKE_CASE       :			Optional[Any]    ):
				"""simple docstring"""







				if args.with_tracking:
								__a       =		Accelerator(
								    cpu=args.cpu				,     mixed_precision=args.mixed_precision				,     log_with="""all"""				,     project_dir=args.project_dir    )
				else:
								__a       =		Accelerator(cpu=args.cpu				,     mixed_precision=args.mixed_precision    )

				# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
				__a       =		config["""lr"""]
				__a       =		int(config["""num_epochs"""]    )
				__a       =		int(config["""seed"""]    )
				__a       =		int(config["""batch_size"""]    )
				__a       =		config["""image_size"""]
				if not isinstance(_SCREAMING_SNAKE_CASE				,     (list, tuple)    ):
								__a       =		(image_size, image_size)

				# Parse out whether we are saving every epoch or after a certain number of batches
				if hasattr(args.checkpointing_steps				,     """isdigit"""    ):
								if args.checkpointing_steps == "epoch":
												__a       =		args.checkpointing_steps
								elif args.checkpointing_steps.isdigit():
												__a       =		int(args.checkpointing_steps    )
								else:
												raise ValueError(
												    f"Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed."    )
				else:
								__a       =		None

				# We need to initialize the trackers we use, and also store our configuration
				if args.with_tracking:
								__a       =		os.path.split(_SCREAMING_SNAKE_CASE    )[-1].split("""."""    )[0]
								accelerator.init_trackers(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )

				# Grab all the image filenames
				__a       =		[os.path.join(args.data_dir				,     _SCREAMING_SNAKE_CASE    ) for fname in os.listdir(args.data_dir    ) if fname.endswith(""".jpg"""    )]

				# Build the label correspondences
				__a       =		[extract_label(_SCREAMING_SNAKE_CASE    ) for fname in file_names]
				__a       =		list(set(_SCREAMING_SNAKE_CASE    )    )
				id_to_label.sort()
				__a       =		{lbl: i for i, lbl in enumerate(_SCREAMING_SNAKE_CASE    )}

				# Set the seed before splitting the data.
				np.random.seed(_SCREAMING_SNAKE_CASE    )
				torch.manual_seed(_SCREAMING_SNAKE_CASE    )
				torch.cuda.manual_seed_all(_SCREAMING_SNAKE_CASE    )

				# Split our filenames between train and validation
				__a       =		np.random.permutation(len(_SCREAMING_SNAKE_CASE    )    )
				__a       =		int(0.8 * len(_SCREAMING_SNAKE_CASE    )    )
				__a       =		random_perm[:cut]
				__a       =		random_perm[cut:]

				# For training we use a simple RandomResizedCrop
				__a       =		Compose([RandomResizedCrop(_SCREAMING_SNAKE_CASE				,     scale=(0.5, 1.0)    ), ToTensor()]    )
				__a       =		PetsDataset(
				    [file_names[i] for i in train_split]				,     image_transform=_SCREAMING_SNAKE_CASE				,     label_to_id=_SCREAMING_SNAKE_CASE    )

				# For evaluation, we use a deterministic Resize
				__a       =		Compose([Resize(_SCREAMING_SNAKE_CASE    ), ToTensor()]    )
				__a       =		PetsDataset([file_names[i] for i in eval_split]				,     image_transform=_SCREAMING_SNAKE_CASE				,     label_to_id=_SCREAMING_SNAKE_CASE    )

				# Instantiate dataloaders.
				__a       =		DataLoader(_SCREAMING_SNAKE_CASE				,     shuffle=_SCREAMING_SNAKE_CASE				,     batch_size=_SCREAMING_SNAKE_CASE				,     num_workers=4    )
				__a       =		DataLoader(_SCREAMING_SNAKE_CASE				,     shuffle=_SCREAMING_SNAKE_CASE				,     batch_size=_SCREAMING_SNAKE_CASE				,     num_workers=4    )

				# Instantiate the model (we build the model here so that the seed also control new weights initialization)
				__a       =		create_model("""resnet50d"""				,     pretrained=_SCREAMING_SNAKE_CASE				,     num_classes=len(_SCREAMING_SNAKE_CASE    )    )

				# We could avoid this line since the accelerator is set with `device_placement=True` (default value).
				# Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
				# creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
				__a       =		model.to(accelerator.device    )

				# Freezing the base model
				for param in model.parameters():
								__a       =		False
				for param in model.get_classifier().parameters():
								__a       =		True

				# We normalize the batches of images to be a bit faster.
				__a       =		torch.tensor(model.default_cfg["""mean"""]    )[None, :, None, None].to(accelerator.device    )
				__a       =		torch.tensor(model.default_cfg["""std"""]    )[None, :, None, None].to(accelerator.device    )

				# Instantiate optimizer
				__a       =		torch.optim.Adam(params=model.parameters()				,     lr=lr / 25    )

				# Instantiate learning rate scheduler
				__a       =		OneCycleLR(optimizer=_SCREAMING_SNAKE_CASE				,     max_lr=_SCREAMING_SNAKE_CASE				,     epochs=_SCREAMING_SNAKE_CASE				,     steps_per_epoch=len(_SCREAMING_SNAKE_CASE    )    )

				# Prepare everything
				# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
				# prepare method.
				__a     ,					__a     ,					__a     ,					__a     ,					__a       =		accelerator.prepare(
				    _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
				# We need to keep track of how many total steps we have iterated over
				__a       =		0
				# We also need to keep track of the starting epoch so files are named properly
				__a       =		0

				# Potentially load in the weights and states from a previous save
				if args.resume_from_checkpoint:
								if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
												accelerator.print(f"Resumed from checkpoint: {args.resume_from_checkpoint}"    )
												accelerator.load_state(args.resume_from_checkpoint    )
												__a       =		os.path.basename(args.resume_from_checkpoint    )
								else:
												# Get the most recent checkpoint
												__a       =		[f.name for f in os.scandir(os.getcwd()    ) if f.is_dir()]
												dirs.sort(key=os.path.getctime    )
												__a       =		dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
								# Extract `epoch_{i}` or `step_{i}`
								__a       =		os.path.splitext(_SCREAMING_SNAKE_CASE    )[0]

								if "epoch" in training_difference:
												__a       =		int(training_difference.replace("""epoch_"""				,     """"""    )    ) + 1
												__a       =		None
								else:
												__a       =		int(training_difference.replace("""step_"""				,     """"""    )    )
												__a       =		resume_step // len(_SCREAMING_SNAKE_CASE    )
												resume_step -= starting_epoch * len(_SCREAMING_SNAKE_CASE    )

    # Now we train the model
				for epoch in range(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    ):
								model.train()
								if args.with_tracking:
												__a       =		0
								if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
												# We need to skip steps until we reach the resumed step
												__a       =		accelerator.skip_first_batches(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )
												overall_step += resume_step
								else:
												# After the first iteration though, we need to go back to the original dataloader
												__a       =		train_dataloader
								for batch in active_dataloader:
												# We could avoid this line since we set the accelerator with `device_placement=True`.
												__a       =		{k: v.to(accelerator.device    ) for k, v in batch.items()}
												__a       =		(batch["""image"""] - mean) / std
												__a       =		model(_SCREAMING_SNAKE_CASE    )
												__a       =		torch.nn.functional.cross_entropy(_SCREAMING_SNAKE_CASE				,     batch["""label"""]    )
												# We keep track of the loss at each epoch
												if args.with_tracking:
																total_loss += loss.detach().float()
												accelerator.backward(_SCREAMING_SNAKE_CASE    )
												optimizer.step()
												lr_scheduler.step()
												optimizer.zero_grad()
												overall_step += 1
												if isinstance(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    ):
																__a       =		f"step_{overall_step}"
																if overall_step % checkpointing_steps == 0:
																				if args.output_dir is not None:
																								__a       =		os.path.join(args.output_dir				,     _SCREAMING_SNAKE_CASE    )
																				accelerator.save_state(_SCREAMING_SNAKE_CASE    )
								model.eval()
								__a       =		0
								__a       =		0
								for step, batch in enumerate(_SCREAMING_SNAKE_CASE    ):
												# We could avoid this line since we set the accelerator with `device_placement=True`.
												__a       =		{k: v.to(accelerator.device    ) for k, v in batch.items()}
												__a       =		(batch["""image"""] - mean) / std
												with torch.no_grad():
																__a       =		model(_SCREAMING_SNAKE_CASE    )
												__a       =		outputs.argmax(dim=-1    )
												__a     ,					__a       =		accelerator.gather_for_metrics((predictions, batch["""label"""])    )
												__a       =		predictions == references
												num_elems += accurate_preds.shape[0]
												accurate += accurate_preds.long().sum()

								__a       =		accurate.item() / num_elems
								# Use accelerator.print to print only on the main process.
								accelerator.print(f"epoch {epoch}: {100 * eval_metric:.2f}"    )
								if args.with_tracking:
												accelerator.log(
												    {
												        """accuracy""": 100 * eval_metric,
												        """train_loss""": total_loss.item() / len(_SCREAMING_SNAKE_CASE    ),
												        """epoch""": epoch,
												    }				,     step=_SCREAMING_SNAKE_CASE				,     )
								if checkpointing_steps == "epoch":
												__a       =		f"epoch_{epoch}"
												if args.output_dir is not None:
																__a       =		os.path.join(args.output_dir				,     _SCREAMING_SNAKE_CASE    )
												accelerator.save_state(_SCREAMING_SNAKE_CASE    )

				if args.with_tracking:
								accelerator.end_training()

def   lowerCAmelCase__						(							):
				"""simple docstring"""







				__a       =		argparse.ArgumentParser(description="""Simple example of training script."""    )
				parser.add_argument("""--data_dir"""				,     required=_SCREAMING_SNAKE_CASE				,     help="""The data folder on disk."""    )
				parser.add_argument("""--fp16"""				,     action="""store_true"""				,     help="""If passed, will use FP16 training."""    )
				parser.add_argument(
				    """--mixed_precision"""				,     type=_SCREAMING_SNAKE_CASE				,     default=_SCREAMING_SNAKE_CASE				,     choices=["""no""", """fp16""", """bf16""", """fp8"""]				,     help="""Whether to use mixed precision. Choose"""
				    """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."""
				    """and an Nvidia Ampere GPU."""				,     )
				parser.add_argument("""--cpu"""				,     action="""store_true"""				,     help="""If passed, will train on the CPU."""    )
				parser.add_argument(
				    """--checkpointing_steps"""				,     type=_SCREAMING_SNAKE_CASE				,     default=_SCREAMING_SNAKE_CASE				,     help="""Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch."""				,     )
				parser.add_argument(
				    """--output_dir"""				,     type=_SCREAMING_SNAKE_CASE				,     default="""."""				,     help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory."""				,     )
				parser.add_argument(
				    """--resume_from_checkpoint"""				,     type=_SCREAMING_SNAKE_CASE				,     default=_SCREAMING_SNAKE_CASE				,     help="""If the training should continue from a checkpoint folder."""				,     )
				parser.add_argument(
				    """--with_tracking"""				,     action="""store_true"""				,     help="""Whether to load in all available experiment trackers from the environment and use them for logging."""				,     )
				parser.add_argument(
				    """--project_dir"""				,     type=_SCREAMING_SNAKE_CASE				,     default="""logs"""				,     help="""Location on where to store experiment tracking logs` and relevent project information"""				,     )
				__a       =		parser.parse_args()
				__a       =		{"""lr""": 3e-2, """num_epochs""": 3, """seed""": 42, """batch_size""": 64, """image_size""": 224}
				training_function(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
						main()





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





							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





							@property
							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		1
											__a       =		3
											__a       =		(32, 32)

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





							@property
							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											torch.manual_seed(0	)
											__a       =		UNetaDConditionModel(
											    block_out_channels=(32, 64)      ,				layers_per_block=2      ,				sample_size=32      ,				in_channels=4      ,				out_channels=4      ,				down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,				up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,				cross_attention_dim=32      ,				)
											return model





							@property
							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											torch.manual_seed(0	)
											__a       =		AutoencoderKL(
											    block_out_channels=[32, 64]      ,				in_channels=3      ,				out_channels=3      ,				down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]      ,				up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]      ,				latent_channels=4      ,				)
											return model





							@property
							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											torch.manual_seed(0	)
											__a       =		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(__lowercase	)





							@property
							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											def extract(*__lowercase		:		Tuple      ,				**__lowercase		:		Dict	):






															class    SCREAMING_SNAKE_CASE			:





																						def __init__(   self		:		List[str]	):

																										'''simple docstring'''
																										__a       =		torch.ones([0]	)







																						def 						UpperCamelCase_					(   self		:		Optional[Any]      ,				__lowercase		:		str	):

																										'''simple docstring'''
																										self.pixel_values.to(__lowercase	)
																										return self



															return Out()

											return extract





							def 						UpperCamelCase_					(   self		:		Dict	):

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

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

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

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

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

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

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

											assert image.shape == (1, 64, 64, 3)
											__a       =		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 						UpperCamelCase_					(   self		:		Tuple	):

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

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

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

											__a       =		output.images

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

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

											assert image.shape == (1, 64, 64, 3)
											__a       =		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 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-lms-pipe"""      ,				safety_checker=__lowercase	)
											assert isinstance(__lowercase      ,				__lowercase	)
											assert isinstance(pipe.scheduler      ,				__lowercase	)
											assert pipe.safety_checker is None

											__a       =		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(__lowercase	)
															__a       =		StableDiffusionPipeline.from_pretrained(__lowercase	)

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







							@unittest.skipIf(torch_device != """cuda"""      ,				"""This test requires a GPU"""	)
							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a       =		self.dummy_cond_unet
											__a       =		PNDMScheduler(skip_prk_steps=__lowercase	)
											__a       =		self.dummy_vae
											__a       =		self.dummy_text_encoder
											__a       =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

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

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

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

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






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





							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""      ,				safety_checker=__lowercase	)
											__a       =		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config	)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		(
											    """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 """
											)
											__a       =		4003660346
											__a       =		7

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

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

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

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

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

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

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

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





							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""      ,				safety_checker=__lowercase	)
											__a       =		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config	)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		"""padme amidala taking a bath artwork, safe for work, no nudity"""
											__a       =		2734971755
											__a       =		7

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

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

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

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

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

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

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

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







							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""	)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

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

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

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

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

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

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