class_docstr: KDPM2DiscreteScheduler with ancestral sampling is inspired by the DPMSolver2 and Algorithm 2 from the [Elucidating
  the Design Space of Diffusion-Based Generative Models](https://huggingface.co/papers/2206.00364) paper.
  
  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.00085):
          The starting `beta` value of inference.
      beta_end (`float`, defaults to 0.012):
          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` or `scaled_linear`.
      trained_betas (`np.ndarray`, *optional*):
          Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.
      use_karras_sigmas (`bool`, *optional*, defaults to `False`):
          Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`,
          the sigmas are determined according to a sequence of noise levels {σi}.
      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).
      timestep_spacing (`str`, defaults to `"linspace"`):
          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.00085,  # sensible defaults
      beta_end: float = 0.012,
      beta_schedule: str = "linear",
      trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
      use_karras_sigmas: Optional[bool] = False,
      prediction_type: str = "epsilon",
      timestep_spacing: str = "linspace",
      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)
      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)
  
      #  set all values
      self.set_timesteps(num_train_timesteps, None, num_train_timesteps)
      self._step_index = None
  
imports: import math
  from collections import defaultdict
  from typing import List, Optional, Tuple, Union
  import numpy
  import torch
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..utils.torch_utils import randn_tensor
  from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
label_desc: Use image node_id 1 to create a new KDPM2AncestralDiscreteScheduler object from inherited base classes: SchedulerMixin, ConfigMixin with example: obj = KDPM2AncestralDiscreteScheduler(num_train_timesteps, beta_start, beta_end, beta_schedule, trained_betas, use_karras_sigmas, prediction_type, timestep_spacing, steps_offset)