class_docstr: `RePaintScheduler` is a scheduler for DDPM inpainting inside a given mask.
  
  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`, `squaredcos_cap_v2`, or `sigmoid`.
      eta (`float`):
          The weight of noise for added noise in diffusion step. If its value is between 0.0 and 1.0 it corresponds
          to the DDIM scheduler, and if its value is between -0.0 and 1.0 it corresponds to the DDPM scheduler.
      trained_betas (`np.ndarray`, *optional*):
          Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.
      clip_sample (`bool`, defaults to `True`):
          Clip the predicted sample between -1 and 1 for numerical stability.
code: def __init__(
      self,
      num_train_timesteps: int = 1000,
      beta_start: float = 0.0001,
      beta_end: float = 0.02,
      beta_schedule: str = "linear",
      eta: float = 0.0,
      trained_betas: Optional[np.ndarray] = None,
      clip_sample: bool = True,
  ):
      if trained_betas is not None:
          self.betas = torch.from_numpy(trained_betas)
      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)
  
      self.final_alpha_cumprod = torch.tensor(1.0)
  
      # standard deviation of the initial noise distribution
      self.init_noise_sigma = 1.0
  
      # setable values
      self.num_inference_steps = None
      self.timesteps = torch.from_numpy(
          np.arange(0, num_train_timesteps)[::-1].copy()
      )
  
      self.eta = eta
  
imports: import math
  from dataclasses import dataclass
  from typing import 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 SchedulerMixin
label_desc: Use image node_id 1 to create a new RePaintScheduler object from inherited base classes: SchedulerMixin, ConfigMixin with example: obj = RePaintScheduler(num_train_timesteps, beta_start, beta_end, beta_schedule, eta, trained_betas, clip_sample)