



_lowercase: Any      			=		"0.18.2"

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
				if not is_onnx_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_onnx_objects import *  # noqa F403
else:
				from .pipelines import OnnxRuntimeModel

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_pt_objects import *  # noqa F403
else:
				from .models import (
				    AutoencoderKL,
				    ControlNetModel,
				    ModelMixin,
				    PriorTransformer,
				    TaFilmDecoder,
				    TransformeraDModel,
				    UNetaDModel,
				    UNetaDConditionModel,
				    UNetaDModel,
				    UNetaDConditionModel,
				    VQModel,
				)
				from .optimization import (
				    get_constant_schedule,
				    get_constant_schedule_with_warmup,
				    get_cosine_schedule_with_warmup,
				    get_cosine_with_hard_restarts_schedule_with_warmup,
				    get_linear_schedule_with_warmup,
				    get_polynomial_decay_schedule_with_warmup,
				    get_scheduler,
				)
				from .pipelines import (
				    AudioPipelineOutput,
				    ConsistencyModelPipeline,
				    DanceDiffusionPipeline,
				    DDIMPipeline,
				    DDPMPipeline,
				    DiffusionPipeline,
				    DiTPipeline,
				    ImagePipelineOutput,
				    KarrasVePipeline,
				    LDMPipeline,
				    LDMSuperResolutionPipeline,
				    PNDMPipeline,
				    RePaintPipeline,
				    ScoreSdeVePipeline,
				)
				from .schedulers import (
				    CMStochasticIterativeScheduler,
				    DDIMInverseScheduler,
				    DDIMParallelScheduler,
				    DDIMScheduler,
				    DDPMParallelScheduler,
				    DDPMScheduler,
				    DEISMultistepScheduler,
				    DPMSolverMultistepInverseScheduler,
				    DPMSolverMultistepScheduler,
				    DPMSolverSinglestepScheduler,
				    EulerAncestralDiscreteScheduler,
				    EulerDiscreteScheduler,
				    HeunDiscreteScheduler,
				    IPNDMScheduler,
				    KarrasVeScheduler,
				    KDPMaAncestralDiscreteScheduler,
				    KDPMaDiscreteScheduler,
				    PNDMScheduler,
				    RePaintScheduler,
				    SchedulerMixin,
				    ScoreSdeVeScheduler,
				    UnCLIPScheduler,
				    UniPCMultistepScheduler,
				    VQDiffusionScheduler,
				)
				from .training_utils import EMAModel

try:
				if not (is_torch_available() and is_scipy_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
				from .schedulers import LMSDiscreteScheduler

try:
				if not (is_torch_available() and is_torchsde_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
				from .schedulers import DPMSolverSDEScheduler

try:
				if not (is_torch_available() and is_transformers_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
				from .pipelines import (
				    AltDiffusionImgaImgPipeline,
				    AltDiffusionPipeline,
				    AudioLDMPipeline,
				    CycleDiffusionPipeline,
				    IFImgaImgPipeline,
				    IFImgaImgSuperResolutionPipeline,
				    IFInpaintingPipeline,
				    IFInpaintingSuperResolutionPipeline,
				    IFPipeline,
				    IFSuperResolutionPipeline,
				    ImageTextPipelineOutput,
				    KandinskyImgaImgPipeline,
				    KandinskyInpaintPipeline,
				    KandinskyPipeline,
				    KandinskyPriorPipeline,
				    KandinskyVaaControlnetImgaImgPipeline,
				    KandinskyVaaControlnetPipeline,
				    KandinskyVaaImgaImgPipeline,
				    KandinskyVaaInpaintPipeline,
				    KandinskyVaaPipeline,
				    KandinskyVaaPriorEmbaEmbPipeline,
				    KandinskyVaaPriorPipeline,
				    LDMTextToImagePipeline,
				    PaintByExamplePipeline,
				    SemanticStableDiffusionPipeline,
				    ShapEImgaImgPipeline,
				    ShapEPipeline,
				    StableDiffusionAttendAndExcitePipeline,
				    StableDiffusionControlNetImgaImgPipeline,
				    StableDiffusionControlNetInpaintPipeline,
				    StableDiffusionControlNetPipeline,
				    StableDiffusionDepthaImgPipeline,
				    StableDiffusionDiffEditPipeline,
				    StableDiffusionImageVariationPipeline,
				    StableDiffusionImgaImgPipeline,
				    StableDiffusionInpaintPipeline,
				    StableDiffusionInpaintPipelineLegacy,
				    StableDiffusionInstructPixaPixPipeline,
				    StableDiffusionLatentUpscalePipeline,
				    StableDiffusionLDMaDPipeline,
				    StableDiffusionModelEditingPipeline,
				    StableDiffusionPanoramaPipeline,
				    StableDiffusionParadigmsPipeline,
				    StableDiffusionPipeline,
				    StableDiffusionPipelineSafe,
				    StableDiffusionPixaPixZeroPipeline,
				    StableDiffusionSAGPipeline,
				    StableDiffusionUpscalePipeline,
				    StableUnCLIPImgaImgPipeline,
				    StableUnCLIPPipeline,
				    TextToVideoSDPipeline,
				    TextToVideoZeroPipeline,
				    UnCLIPImageVariationPipeline,
				    UnCLIPPipeline,
				    UniDiffuserModel,
				    UniDiffuserPipeline,
				    UniDiffuserTextDecoder,
				    VersatileDiffusionDualGuidedPipeline,
				    VersatileDiffusionImageVariationPipeline,
				    VersatileDiffusionPipeline,
				    VersatileDiffusionTextToImagePipeline,
				    VideoToVideoSDPipeline,
				    VQDiffusionPipeline,
				)

try:
				if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
				from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
				if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
				from .pipelines import StableDiffusionKDiffusionPipeline

try:
				if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
				from .pipelines import (
				    OnnxStableDiffusionImgaImgPipeline,
				    OnnxStableDiffusionInpaintPipeline,
				    OnnxStableDiffusionInpaintPipelineLegacy,
				    OnnxStableDiffusionPipeline,
				    OnnxStableDiffusionUpscalePipeline,
				    StableDiffusionOnnxPipeline,
				)

try:
				if not (is_torch_available() and is_librosa_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
				from .pipelines import AudioDiffusionPipeline, Mel

try:
				if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
				from .pipelines import SpectrogramDiffusionPipeline

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_flax_objects import *  # noqa F403
else:
				from .models.controlnet_flax import FlaxControlNetModel
				from .models.modeling_flax_utils import FlaxModelMixin
				from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
				from .models.vae_flax import FlaxAutoencoderKL
				from .pipelines import FlaxDiffusionPipeline
				from .schedulers import (
				    FlaxDDIMScheduler,
				    FlaxDDPMScheduler,
				    FlaxDPMSolverMultistepScheduler,
				    FlaxKarrasVeScheduler,
				    FlaxLMSDiscreteScheduler,
				    FlaxPNDMScheduler,
				    FlaxSchedulerMixin,
				    FlaxScoreSdeVeScheduler,
				)


try:
				if not (is_flax_available() and is_transformers_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
				from .pipelines import (
				    FlaxStableDiffusionControlNetPipeline,
				    FlaxStableDiffusionImgaImgPipeline,
				    FlaxStableDiffusionInpaintPipeline,
				    FlaxStableDiffusionPipeline,
				)

try:
				if not (is_note_seq_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from .utils.dummy_note_seq_objects import *  # noqa F403
else:
				from .pipelines import MidiProcessor





import torch

from diffusers import DDPMScheduler

from .test_schedulers import SchedulerCommonTest



class 	_lowercase							(   lowerCAmelCase	):





	"""simple docstring"""
	__A							=							(DDPMScheduler,)




	def      UpperCamelCase_       (self		,       **lowerCamelCase_		):
						"""simple docstring"""

						a					     =   {
						    "num_train_timesteps": 1000,
						    "beta_start": 0.0001,
						    "beta_end": 0.02,
						    "beta_schedule": "linear",
						    "variance_type": "fixed_small",
						    "clip_sample": True,
						}

						config.update(**lowerCamelCase_		)
						return config




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for timesteps in [1, 5, 100, 1000]:
											self.check_over_configs(num_train_timesteps=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for beta_start, beta_end in zip([0.0001, 0.001, 0.01, 0.1]		,       [0.002, 0.02, 0.2, 2]		):
											self.check_over_configs(beta_start=lowerCamelCase_		,       beta_end=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for schedule in ["linear", "squaredcos_cap_v2"]:
											self.check_over_configs(beta_schedule=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for variance in ["fixed_small", "fixed_large", "other"]:
											self.check_over_configs(variance_type=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for clip_sample in [True, False]:
											self.check_over_configs(clip_sample=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						self.check_over_configs(thresholding=lowerCamelCase_		)
						for threshold in [0.5, 1.0, 2.0]:
											for prediction_type in ["epsilon", "sample", "v_prediction"]:
																self.check_over_configs(
																    thresholding=lowerCamelCase_		,       prediction_type=lowerCamelCase_		,       sample_max_value=lowerCamelCase_		,       )




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for prediction_type in ["epsilon", "sample", "v_prediction"]:
											self.check_over_configs(prediction_type=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						for t in [0, 500, 999]:
											self.check_over_forward(time_step=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config()
						a					     =   scheduler_class(**lowerCamelCase_		)

						assert torch.sum(torch.abs(scheduler._get_variance(0		) - 0.0		)		) < 1E-5
						assert torch.sum(torch.abs(scheduler._get_variance(487		) - 0.0_0979		)		) < 1E-5
						assert torch.sum(torch.abs(scheduler._get_variance(999		) - 0.02		)		) < 1E-5




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config()
						a					     =   scheduler_class(**lowerCamelCase_		)

						a					     =   len(lowerCamelCase_		)

						a					     =   self.dummy_model()
						a					     =   self.dummy_sample_deter
						a					     =   torch.manual_seed(0		)

						for t in reversed(range(lowerCamelCase_		)		):
											# 1. predict noise residual
											a					     =   model(lowerCamelCase_		,       lowerCamelCase_		)

											# 2. predict previous mean of sample x_t-1
											a					     =   scheduler.step(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_		,       generator=lowerCamelCase_		).prev_sample

											# if t > 0:
											#     noise = self.dummy_sample_deter
											#     variance = scheduler.get_variance(t) ** (0.5) * noise
											#
											# sample = pred_prev_sample + variance
											a					     =   pred_prev_sample

						a					     =   torch.sum(torch.abs(lowerCamelCase_		)		)
						a					     =   torch.mean(torch.abs(lowerCamelCase_		)		)

						assert abs(result_sum.item() - 258.9606		) < 1E-2
						assert abs(result_mean.item() - 0.3372		) < 1E-3




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config(prediction_type="v_prediction"		)
						a					     =   scheduler_class(**lowerCamelCase_		)

						a					     =   len(lowerCamelCase_		)

						a					     =   self.dummy_model()
						a					     =   self.dummy_sample_deter
						a					     =   torch.manual_seed(0		)

						for t in reversed(range(lowerCamelCase_		)		):
											# 1. predict noise residual
											a					     =   model(lowerCamelCase_		,       lowerCamelCase_		)

											# 2. predict previous mean of sample x_t-1
											a					     =   scheduler.step(lowerCamelCase_		,       lowerCamelCase_		,       lowerCamelCase_		,       generator=lowerCamelCase_		).prev_sample

											# if t > 0:
											#     noise = self.dummy_sample_deter
											#     variance = scheduler.get_variance(t) ** (0.5) * noise
											#
											# sample = pred_prev_sample + variance
											a					     =   pred_prev_sample

						a					     =   torch.sum(torch.abs(lowerCamelCase_		)		)
						a					     =   torch.mean(torch.abs(lowerCamelCase_		)		)

						assert abs(result_sum.item() - 202.0296		) < 1E-2
						assert abs(result_mean.item() - 0.2631		) < 1E-3




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config()
						a					     =   scheduler_class(**lowerCamelCase_		)

						a					     =   [100, 87, 50, 1, 0]

						scheduler.set_timesteps(timesteps=lowerCamelCase_		)

						a					     =   scheduler.timesteps

						for i, timestep in enumerate(lowerCamelCase_		):
											if i == len(lowerCamelCase_		) - 1:
																a					     =   -1
											else:
																a					     =   timesteps[i + 1]

											a					     =   scheduler.previous_timestep(lowerCamelCase_		)
											a					     =   prev_t.item()

											self.assertEqual(lowerCamelCase_		,       lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config()
						a					     =   scheduler_class(**lowerCamelCase_		)

						a					     =   [100, 87, 50, 51, 0]

						with self.assertRaises(lowerCamelCase_		,       msg="`custom_timesteps` must be in descending order."		):
											scheduler.set_timesteps(timesteps=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config()
						a					     =   scheduler_class(**lowerCamelCase_		)

						a					     =   [100, 87, 50, 1, 0]
						a					     =   len(lowerCamelCase_		)

						with self.assertRaises(lowerCamelCase_		,       msg="Can only pass one of `num_inference_steps` or `custom_timesteps`."		):
											scheduler.set_timesteps(num_inference_steps=lowerCamelCase_		,       timesteps=lowerCamelCase_		)




	def      UpperCamelCase_       (self		):
						"""simple docstring"""

						a					     =   self.scheduler_classes[0]
						a					     =   self.get_scheduler_config()
						a					     =   scheduler_class(**lowerCamelCase_		)

						a					     =   [scheduler.config.num_train_timesteps]

						with self.assertRaises(
						    lowerCamelCase_		,       msg="`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}"		,       ):
											scheduler.set_timesteps(timesteps=lowerCamelCase_		)
