class_docstr: `DDPMScheduler` explores the connections between denoising score matching and Langevin dynamics sampling.
  
  This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
  methods the library implements for all schedulers such as loading and saving.
  
  Args:
      num_train_timesteps (`int`, defaults to 1000):
          The number of diffusion steps to train the model.
      beta_start (`float`, defaults to 0.0001):
          The starting `beta` value of inference.
      beta_end (`float`, defaults to 0.02):
          The final `beta` value.
      beta_schedule (`str`, defaults to `"linear"`):
          The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
          `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
      variance_type (`str`, defaults to `"fixed_small"`):
          Clip the variance when adding noise to the denoised sample. Choose from `fixed_small`, `fixed_small_log`,
          `fixed_large`, `fixed_large_log`, `learned` or `learned_range`.
      clip_sample (`bool`, defaults to `True`):
          Clip the predicted sample for numerical stability.
      clip_sample_range (`float`, defaults to 1.0):
          The maximum magnitude for sample clipping. Valid only when `clip_sample=True`.
      prediction_type (`str`, defaults to `epsilon`, *optional*):
          Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process),
          `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen
          Video](https://imagen.research.google/video/paper.pdf) paper).
      thresholding (`bool`, defaults to `False`):
          Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such
          as Stable Diffusion.
      dynamic_thresholding_ratio (`float`, defaults to 0.995):
          The ratio for the dynamic thresholding method. Valid only when `thresholding=True`.
      sample_max_value (`float`, defaults to 1.0):
          The threshold value for dynamic thresholding. Valid only when `thresholding=True`.
      timestep_spacing (`str`, defaults to `"leading"`):
          The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
          Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
      steps_offset (`int`, defaults to 0):
          An offset added to the inference steps. You can use a combination of `offset=1` and
          `set_alpha_to_one=False` to make the last step use step 0 for the previous alpha product like in Stable
          Diffusion.
code: def __init__(
      self,
      num_train_timesteps: int = 1000,
      beta_start: float = 0.0001,
      beta_end: float = 0.02,
      beta_schedule: str = "linear",
      trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
      variance_type: str = "fixed_small",
      clip_sample: bool = True,
      prediction_type: str = "epsilon",
      thresholding: bool = False,
      dynamic_thresholding_ratio: float = 0.995,
      clip_sample_range: float = 1.0,
      sample_max_value: float = 1.0,
      timestep_spacing: str = "leading",
      steps_offset: int = 0,
  ):
      if trained_betas is not None:
          self.betas = torch.tensor(trained_betas, dtype=torch.float32)
      elif beta_schedule == "linear":
          self.betas = torch.linspace(
              beta_start,
              beta_end,
              num_train_timesteps,
              dtype=torch.float32,
          )
      elif beta_schedule == "scaled_linear":
          # this schedule is very specific to the latent diffusion model.
          self.betas = (
              torch.linspace(
                  beta_start**0.5,
                  beta_end**0.5,
                  num_train_timesteps,
                  dtype=torch.float32,
              )
              ** 2
          )
      elif beta_schedule == "squaredcos_cap_v2":
          # Glide cosine schedule
          self.betas = betas_for_alpha_bar(num_train_timesteps)
      elif beta_schedule == "sigmoid":
          # GeoDiff sigmoid schedule
          betas = torch.linspace(-6, 6, num_train_timesteps)
          self.betas = (
              torch.sigmoid(betas) * (beta_end - beta_start)
              + beta_start
          )
      else:
          raise NotImplementedError(
              f"{beta_schedule} does is not implemented for {self.__class__}"
          )
  
      self.alphas = 1.0 - self.betas
      self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
      self.one = torch.tensor(1.0)
  
      # standard deviation of the initial noise distribution
      self.init_noise_sigma = 1.0
  
      # setable values
      self.custom_timesteps = False
      self.num_inference_steps = None
      self.timesteps = torch.from_numpy(
          np.arange(0, num_train_timesteps)[::-1].copy()
      )
  
      self.variance_type = variance_type
  
imports: import math
  from dataclasses import dataclass
  from typing import List, Optional, Tuple, Union
  import numpy
  import torch
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..utils import BaseOutput
  from ..utils.torch_utils import randn_tensor
  from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin
label_desc: Use image node_id 1 to create a new DDPMScheduler object from inherited base classes: SchedulerMixin, ConfigMixin with example: obj = DDPMScheduler(num_train_timesteps, beta_start, beta_end, beta_schedule, trained_betas, variance_type, clip_sample, prediction_type, thresholding, dynamic_thresholding_ratio, clip_sample_range, sample_max_value, timestep_spacing, steps_offset)