



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()


class  _lowercase				(unittest.TestCase ):
				'''simple docstring'''







				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


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

				@property
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				1
									UpperCamelCase_											=				3
									UpperCamelCase_											=				(32, 32)

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

				@property
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


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

				@property
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


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

				@property
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									torch.manual_seed(0      )
									UpperCamelCase_											=				CLIPTextConfig(
									    bos_token_id=0       ,	eos_token_id=2       ,	hidden_size=32       ,	intermediate_size=37       ,	layer_norm_eps=1e-05       ,	num_attention_heads=4       ,	num_hidden_layers=5       ,	pad_token_id=1       ,	vocab_size=1000       ,	)
									return CLIPTextModel(_UpperCAmelCase      )

				@property
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									def extract(*snake_case__       ,	**snake_case__      ):


														class  _lowercase				:
																		'''simple docstring'''







																		def __init__(	self      ):

																							'''simple docstring'''


																							UpperCamelCase_											=				torch.ones([0]      )

																		def  _lowerCamelCase   (	self       ,	snake_case__      ):

																							'''simple docstring'''


																							self.pixel_values.to(_UpperCAmelCase      )
																							return self




														return Out()

									return extract

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"cpu"  # ensure determinism for the device-dependent torch.Generator
									UpperCamelCase_											=				self.dummy_cond_unet
									UpperCamelCase_											=				DDIMScheduler(
									    beta_start=0.00_085       ,	beta_end=0.012       ,	beta_schedule="scaled_linear"       ,	clip_sample=_UpperCAmelCase       ,	set_alpha_to_one=_UpperCAmelCase       ,	)

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

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

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

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

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

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

									assert image.shape == (1, 64, 64, 3)
									UpperCamelCase_											=				np.array([0.5_753, 0.6_114, 0.5_001, 0.5_034, 0.5_470, 0.4_729, 0.4_971, 0.4_867, 0.4_867]      )

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

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


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

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

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

									UpperCamelCase_											=				output.images

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

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

									assert image.shape == (1, 64, 64, 3)
									UpperCamelCase_											=				np.array([0.5_122, 0.5_712, 0.4_825, 0.5_053, 0.5_646, 0.4_769, 0.5_179, 0.4_894, 0.4_994]      )

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

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


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

									UpperCamelCase_											=				pipe("example prompt"       ,	num_inference_steps=2      ).images[0]
									assert image is not None

									# check that there's no error when saving a pipeline with one of the models being None
									with tempfile.TemporaryDirectory() as tmpdirname:
														pipe.save_pretrained(_UpperCAmelCase      )
														UpperCamelCase_											=				StableDiffusionPipeline.from_pretrained(_UpperCAmelCase      )

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

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

									'''simple docstring'''


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

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

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

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

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




@nightly
@require_torch_gpu
class  _lowercase				(unittest.TestCase ):
				'''simple docstring'''







				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


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

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"cuda"
									UpperCamelCase_											=				StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"      )
									UpperCamelCase_											=				pipe.to(_UpperCAmelCase      )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase      )

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

									UpperCamelCase_											=				3
									UpperCamelCase_											=				7

									# no sega enabled
									UpperCamelCase_											=				torch.Generator(_UpperCAmelCase      )
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.34_673_113,
									    0.38_492_733,
									    0.37_597_352,
									    0.34_086_335,
									    0.35_650_748,
									    0.35_579_205,
									    0.3_384_763,
									    0.34_340_236,
									    0.3_573_271,
									]

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

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	**_UpperCAmelCase       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.41_887_826,
									    0.37_728_766,
									    0.30_138_272,
									    0.41_416_335,
									    0.41_664_985,
									    0.36_283_392,
									    0.36_191_246,
									    0.43_364_465,
									    0.43_001_732,
									]

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

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

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"cuda"
									UpperCamelCase_											=				StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"      )
									UpperCamelCase_											=				pipe.to(_UpperCAmelCase      )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase      )

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

									UpperCamelCase_											=				9
									UpperCamelCase_											=				7

									# no sega enabled
									UpperCamelCase_											=				torch.Generator(_UpperCAmelCase      )
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.43_497_998,
									    0.91_814_065,
									    0.7_540_739,
									    0.55_580_205,
									    0.8_467_265,
									    0.5_389_691,
									    0.62_574_506,
									    0.58_897_763,
									    0.50_926_757,
									]

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

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	**_UpperCAmelCase       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.3_089_719,
									    0.30_500_144,
									    0.29_016_042,
									    0.30_630_964,
									    0.325_687,
									    0.29_419_225,
									    0.2_908_091,
									    0.28_723_598,
									    0.27_696_294,
									]

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

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

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"cuda"
									UpperCamelCase_											=				StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"      )
									UpperCamelCase_											=				pipe.to(_UpperCAmelCase      )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase      )

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

									UpperCamelCase_											=				48
									UpperCamelCase_											=				7

									# no sega enabled
									UpperCamelCase_											=				torch.Generator(_UpperCAmelCase      )
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.75_163_555,
									    0.76_037_145,
									    0.61_785,
									    0.9_189_673,
									    0.8_627_701,
									    0.85_189_694,
									    0.8_512_813,
									    0.87_012_076,
									    0.8_312_857,
									]

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

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	**_UpperCAmelCase       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.73_553_365,
									    0.7_537_271,
									    0.74_341_905,
									    0.66_480_356,
									    0.6_472_925,
									    0.63_039_416,
									    0.64_812_905,
									    0.6_749_717,
									    0.6_517_102,
									]

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

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

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"cuda"
									UpperCamelCase_											=				StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"       ,	torch_dtype=torch.floataa      )
									UpperCamelCase_											=				pipe.to(_UpperCAmelCase      )
									pipe.set_progress_bar_config(disable=_UpperCAmelCase      )

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

									UpperCamelCase_											=				3
									UpperCamelCase_											=				7

									# no sega enabled
									UpperCamelCase_											=				torch.Generator(_UpperCAmelCase      )
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.34_887_695,
									    0.3_876_953,
									    0.375,
									    0.34_423_828,
									    0.3_581_543,
									    0.35_717_773,
									    0.3_383_789,
									    0.34_570_312,
									    0.359_375,
									]

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

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

									# with sega enabled
									# generator = torch.manual_seed(seed)
									generator.manual_seed(_UpperCAmelCase      )
									UpperCamelCase_											=				pipe(
									    [prompt]       ,	generator=_UpperCAmelCase       ,	guidance_scale=_UpperCAmelCase       ,	num_inference_steps=50       ,	output_type="np"       ,	width=512       ,	height=512       ,	**_UpperCAmelCase       ,	)

									UpperCamelCase_											=				output.images
									UpperCamelCase_											=				image[0, -3:, -3:, -1]
									UpperCamelCase_											=				[
									    0.42_285_156,
									    0.36_914_062,
									    0.29_077_148,
									    0.42_041_016,
									    0.41_918_945,
									    0.35_498_047,
									    0.3_618_164,
									    0.4_423_828,
									    0.43_115_234,
									]

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

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





from typing import List, Optional, Tuple, Union

from . import logging
from .import_utils import is_torch_available, is_torch_version


if is_torch_available():
	import torch

UpperCAmelCase				:							Any								=logging.get_logger(__name__)  # pylint: disable=invalid-name

try:
	from torch._dynamo import allow_in_graph as maybe_allow_in_graph
except (ImportError, ModuleNotFoundError):



	def 				_lowerCAmelCase      (cls):
						return cls



def 				_lowerCAmelCase      (_lowerCAmelCase				,		_lowerCAmelCase = None				,		_lowerCAmelCase = None				,		_lowerCAmelCase = None				,		_lowerCAmelCase = None				,		):
					UpperCamelCase_											=				device
					UpperCamelCase_											=				shape[0]

					UpperCamelCase_											=				layout or torch.strided
					UpperCamelCase_											=				device or torch.device("cpu")

					if generator is not None:
										UpperCamelCase_											=				generator.device.type if not isinstance(_lowerCAmelCase				,		_lowerCAmelCase) else generator[0].device.type
										if gen_device_type != device.type and gen_device_type == "cpu":
															UpperCamelCase_											=				"cpu"
															if device != "mps":
																				logger.info(
																				    f"""The passed generator was created on 'cpu' even though a tensor on {device} was expected."""
																				    f""" Tensors will be created on 'cpu' and then moved to {device}. Note that one can probably"""
																				    f""" slighly speed up this function by passing a generator that was created on the {device} device.""")
										elif gen_device_type != device.type and gen_device_type == "cuda":
															raise ValueError(f"""Cannot generate a {device} tensor from a generator of type {gen_device_type}.""")

					if isinstance(_lowerCAmelCase				,		_lowerCAmelCase):
										UpperCamelCase_											=				(1,) + shape[1:]
										UpperCamelCase_											=				[
										    torch.randn(_lowerCAmelCase				,		generator=generator[i]				,		device=_lowerCAmelCase				,		dtype=_lowerCAmelCase				,		layout=_lowerCAmelCase)
										    for i in range(_lowerCAmelCase)
										]
										UpperCamelCase_											=				torch.cat(_lowerCAmelCase				,		dim=0).to(_lowerCAmelCase)
					else:
										UpperCamelCase_											=				torch.randn(_lowerCAmelCase				,		generator=_lowerCAmelCase				,		device=_lowerCAmelCase				,		dtype=_lowerCAmelCase				,		layout=_lowerCAmelCase).to(_lowerCAmelCase)

					return latents






def 				_lowerCAmelCase      (_lowerCAmelCase):
					if is_torch_version("<"				,		"2.0.0") or not hasattr(_lowerCAmelCase				,		"_dynamo"):
										return False
					return isinstance(_lowerCAmelCase				,		torch._dynamo.eval_frame.OptimizedModule)
