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.
docstr: Sets the discrete timesteps used for the diffusion chain (to be run before inference).
  
  Args:
      num_inference_steps (`int`):
          The number of diffusion steps used when generating samples with a pre-trained model.
      device (`str` or `torch.device`, *optional*):
          The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
docstr_tok: ["Sets","the","discrete","timesteps","used","for","the","diffusion","chain","(","to","be","run","before","inference",")",".","Args",":","num_inference_steps","(","`","int","`",")",":","The","number","of","diffusion","steps","used","when","generating","samples","with","a","pre-trained","model",".","device","(","`","str","`","or","`","torch.device","`",",","*","optional","*",")",":","The","device","to","which","the","timesteps","should","be","moved","to",".","If","`","None","`",",","the","timesteps","are","not","moved","."]
code: def set_timesteps(
      self,
      num_inference_steps: int,
      device: Union[str, torch.device] = None,
  ):
      """
      Sets the discrete timesteps used for the diffusion chain (to be run before inference).
  
      Args:
          num_inference_steps (`int`):
              The number of diffusion steps used when generating samples with a pre-trained model.
          device (`str` or `torch.device`, *optional*):
              The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
      """
      self.num_inference_steps = num_inference_steps
      # Clipping the minimum of all lambda(t) for numerical stability.
      # This is critical for cosine (squaredcos_cap_v2) noise schedule.
      clipped_idx = torch.searchsorted(
          torch.flip(self.lambda_t, [0]), self.config.lambda_min_clipped
      )
      timesteps = (
          np.linspace(
              0,
              self.config.num_train_timesteps - 1 - clipped_idx,
              num_inference_steps + 1,
          )
          .round()[::-1][:-1]
          .copy()
          .astype(np.int64)
      )
  
      sigmas = np.array(
          ((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5
      )
      if self.config.use_karras_sigmas:
          log_sigmas = np.log(sigmas)
          sigmas = np.flip(sigmas).copy()
          sigmas = self._convert_to_karras(
              in_sigmas=sigmas, num_inference_steps=num_inference_steps
          )
          timesteps = np.array(
              [self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]
          ).round()
          sigmas = np.concatenate([sigmas, sigmas[-1:]]).astype(
              np.float32
          )
      else:
          sigmas = np.interp(
              timesteps, np.arange(0, len(sigmas)), sigmas
          )
          sigma_last = (
              (1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]
          ) ** 0.5
          sigmas = np.concatenate([sigmas, [sigma_last]]).astype(
              np.float32
          )
  
      self.sigmas = torch.from_numpy(sigmas).to(device=device)
  
      self.timesteps = torch.from_numpy(timesteps).to(
          device=device, dtype=torch.int64
      )
      self.model_outputs = [None] * self.config.solver_order
      self.sample = None
  
      if (
          not self.config.lower_order_final
          and num_inference_steps % self.config.solver_order != 0
      ):
          logger.warn(
              "Changing scheduler {self.config} to have `lower_order_final` set to True to handle uneven amount of inference steps. Please make sure to always use an even number of `num_inference steps when using `lower_order_final=True`."
          )
          self.register_to_config(lower_order_final=True)
  
      self.order_list = self.get_order_list(num_inference_steps)
  
      # add an index counter for schedulers that allow duplicated timesteps
      self._step_index = None
  
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 4 for calling the DPMSolverSinglestepScheduler obj's underlying member method code with example usage: obj.set_timesteps(num_inference_steps, device) without return types