class_docstr: `DPMSolverSinglestepScheduler` is a fast dedicated high-order solver for diffusion ODEs.
  
  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`.
      trained_betas (`np.ndarray`, *optional*):
          Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.
      solver_order (`int`, defaults to 2):
          The DPMSolver order which can be `1` or `2` or `3`. It is recommended to use `solver_order=2` for guided
          sampling, and `solver_order=3` for unconditional sampling.
      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` and
          `algorithm_type="dpmsolver++"`.
      algorithm_type (`str`, defaults to `dpmsolver++`):
          Algorithm type for the solver; can be `dpmsolver`, `dpmsolver++`, `sde-dpmsolver` or `sde-dpmsolver++`. The
          `dpmsolver` type implements the algorithms in the [DPMSolver](https://huggingface.co/papers/2206.00927)
          paper, and the `dpmsolver++` type implements the algorithms in the
          [DPMSolver++](https://huggingface.co/papers/2211.01095) paper. It is recommended to use `dpmsolver++` or
          `sde-dpmsolver++` with `solver_order=2` for guided sampling like in Stable Diffusion.
      solver_type (`str`, defaults to `midpoint`):
          Solver type for the second-order solver; can be `midpoint` or `heun`. The solver type slightly affects the
          sample quality, especially for a small number of steps. It is recommended to use `midpoint` solvers.
      lower_order_final (`bool`, defaults to `True`):
          Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can
          stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10.
      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}.
      lambda_min_clipped (`float`, defaults to `-inf`):
          Clipping threshold for the minimum value of `lambda(t)` for numerical stability. This is critical for the
          cosine (`squaredcos_cap_v2`) noise schedule.
      variance_type (`str`, *optional*):
          Set to "learned" or "learned_range" for diffusion models that predict variance. If set, the model's output
          contains the predicted Gaussian variance.
code: def add_noise(
      self,
      original_samples: torch.FloatTensor,
      noise: torch.FloatTensor,
      timesteps: torch.IntTensor,
  ) -> torch.FloatTensor:
      # Make sure sigmas and timesteps have the same device and dtype as original_samples
      sigmas = self.sigmas.to(
          device=original_samples.device, dtype=original_samples.dtype
      )
      if (
          original_samples.device.type == "mps"
          and torch.is_floating_point(timesteps)
      ):
          # mps does not support float64
          schedule_timesteps = self.timesteps.to(
              original_samples.device, dtype=torch.float32
          )
          timesteps = timesteps.to(
              original_samples.device, dtype=torch.float32
          )
      else:
          schedule_timesteps = self.timesteps.to(
              original_samples.device
          )
          timesteps = timesteps.to(original_samples.device)
  
      step_indices = [
          (schedule_timesteps == t).nonzero().item() for t in timesteps
      ]
  
      sigma = sigmas[step_indices].flatten()
      while len(sigma.shape) < len(original_samples.shape):
          sigma = sigma.unsqueeze(-1)
  
      alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
      noisy_samples = alpha_t * original_samples + sigma_t * noise
      return noisy_samples
  
imports: import math
  from typing import List, Optional, Tuple, Union
  import numpy
  import torch
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..utils import deprecate, logging
  from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
label_desc: Use image node_id 17 for calling the DPMSolverSinglestepScheduler obj's underlying member method code with example usage: obj.add_noise(original_samples, noise, timesteps) and returns: noisy_samples