Diffusers contains multiple pre-built schedule functions for the diffusion process.
The schedule functions, denoted Schedulers in the library take in the output of a trained model, a sample which the diffusion process is iterating on, and a timestep to return a denoised sample.
All schedulers take in a timestep to predict the updated version of the sample being diffused.
The timesteps dictate where in the diffusion process the step is, where data is generated by iterating forward in time and inference is executed by propagating backwards through timesteps.
Different algorithms use timesteps that both discrete (accepting int inputs), such as the DDPMScheduler or PNDMScheduler, and continuous (accepting float inputs), such as the score-based schedulers ScoreSdeVeScheduler or ScoreSdeVpScheduler.
The core design principle between the schedule functions is to be model, system, and framework independent. This allows for rapid experimentation and cleaner abstractions in the code, where the model prediction is separated from the sample update. To this end, the design of schedulers is such that:
The core API for any new scheduler must follow a limited structure.
def step(...) functions that should be called to update the generated sample iteratively.set_timesteps(...) method that configures the parameters of a schedule function for a specific inference task.The base class SchedulerMixin implements low level utilities used by multiple schedulers.
Mixin containing common functions for the schedulers.
( prev_sample: FloatTensor )
Base class for the scheduler’s step function output.
Original paper can be found here.
( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: typing.Optional[numpy.ndarray] = None clip_sample: bool = True set_alpha_to_one: bool = True steps_offset: int = 0 )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
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.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
bool, default True) —
option to clip predicted sample between -1 and 1 for numerical stability.
bool, default True) —
each diffusion step uses the value of alphas product at that step and at the previous one. For the final
step there is no previous alpha. When this option is True the previous alpha product is fixed to 1,
otherwise it uses the value of alpha at step 0.
int, default 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, as done in
stable diffusion.
Denoising diffusion implicit models is a scheduler that extends the denoising procedure introduced in denoising diffusion probabilistic models (DDPMs) with non-Markovian guidance.
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details, see the original paper: https://arxiv.org/abs/2010.02502
(
sample: FloatTensor
timestep: typing.Optional[int] = None
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
eta: float = 0.0
use_clipped_model_output: bool = False
generator = None
return_dict: bool = True
)
→
~schedulers.scheduling_utils.DDIMSchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
float) — weight of noise for added noise in diffusion step.
bool) — if True, compute “corrected” model_output from the clipped
predicted original sample. Necessary because predicted original sample is clipped to [-1, 1] when
self.config.clip_sample is True. If no clipping has happened, “corrected” model_output would
coincide with the one provided as input and use_clipped_model_output will have not effect.
generator — random number generator.
bool) — option for returning tuple rather than DDIMSchedulerOutput class
Returns
~schedulers.scheduling_utils.DDIMSchedulerOutput or tuple
~schedulers.scheduling_utils.DDIMSchedulerOutput if return_dict is True, otherwise a tuple. When
returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
Original paper can be found here.
( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: typing.Optional[numpy.ndarray] = None variance_type: str = 'fixed_small' clip_sample: bool = True )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
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.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
str) —
options to clip the variance used when adding noise to the denoised sample. Choose from fixed_small,
fixed_small_log, fixed_large, fixed_large_log, learned or learned_range.
bool, default True) —
option to clip predicted sample between -1 and 1 for numerical stability.
Denoising diffusion probabilistic models (DDPMs) explores the connections between denoising score matching and Langevin dynamics sampling.
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details, see the original paper: https://arxiv.org/abs/2006.11239
(
sample: FloatTensor
timestep: typing.Optional[int] = None
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
predict_epsilon = True
generator = None
return_dict: bool = True
)
→
~schedulers.scheduling_utils.DDPMSchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
bool) —
optional flag to use when model predicts the samples directly instead of the noise, epsilon.
generator — random number generator.
bool) — option for returning tuple rather than DDPMSchedulerOutput class
Returns
~schedulers.scheduling_utils.DDPMSchedulerOutput or tuple
~schedulers.scheduling_utils.DDPMSchedulerOutput if return_dict is True, otherwise a tuple. When
returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
Original paper can be found here.
( sigma_min: float = 0.02 sigma_max: float = 100 s_noise: float = 1.007 s_churn: float = 80 s_min: float = 0.05 s_max: float = 50 )
Parameters
float) — minimum noise magnitude
float) — maximum noise magnitude
float) — the amount of additional noise to counteract loss of detail during sampling.
A reasonable range is [1.000, 1.011].
float) — the parameter controlling the overall amount of stochasticity.
A reasonable range is [0, 100].
float) — the start value of the sigma range where we add noise (enable stochasticity).
A reasonable range is [0, 10].
float) — the end value of the sigma range where we add noise.
A reasonable range is [0.2, 80].
Stochastic sampling from Karras et al. [1] tailored to the Variance-Expanding (VE) models [2]. Use Algorithm 2 and the VE column of Table 1 from [1] for reference.
[1] Karras, Tero, et al. “Elucidating the Design Space of Diffusion-Based Generative Models.” https://arxiv.org/abs/2206.00364 [2] Song, Yang, et al. “Score-based generative modeling through stochastic differential equations.” https://arxiv.org/abs/2011.13456
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details on the parameters, see the original paper’s Appendix E.: “Elucidating the Design Space of Diffusion-Based Generative Models.” https://arxiv.org/abs/2206.00364. The grid search values used to find the optimal {s_noise, s_churn, s_min, s_max} for a specific model are described in Table 5 of the paper.
( sample: FloatTensor sigma: float generator: typing.Optional[torch._C.Generator] = None )
Explicit Langevin-like “churn” step of adding noise to the sample according to a factor gamma_i ≥ 0 to reach a higher noise level sigma_hat = sigma_i + gamma_i*sigma_i.
TODO Args:
(
sample: FloatTensor
timestep: typing.Optional[int] = None
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
sigma_hat: float
sigma_prev: float
sample_hat: FloatTensor
return_dict: bool = True
)
→
KarrasVeOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
float) — TODO
float) — TODO
torch.FloatTensor) — TODO
bool) — option for returning tuple rather than KarrasVeOutput class
KarrasVeOutput — updated sample in the diffusion chain and derivative (TODO double check).
Returns
KarrasVeOutput or tuple
KarrasVeOutput if return_dict is True, otherwise a tuple. When
returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
( model_output: FloatTensor sigma_hat: float sigma_prev: float sample_hat: FloatTensor sample_prev: FloatTensor derivative: FloatTensor return_dict: bool = True ) → prev_sample (TODO)
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
float) — TODO
float) — TODO
torch.FloatTensor) — TODO
torch.FloatTensor) — TODO
torch.FloatTensor) — TODO
bool) — option for returning tuple rather than KarrasVeOutput class
Returns
prev_sample (TODO)
updated sample in the diffusion chain. derivative (TODO): TODO
Correct the predicted sample based on the output model_output of the network. TODO complete description
Original implementation can be found here.
( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: typing.Optional[numpy.ndarray] = None )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
linear or scaled_linear.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
Linear Multistep Scheduler for discrete beta schedules. Based on the original k-diffusion implementation by Katherine Crowson: https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
( order t current_order )
Compute a linear multistep coefficient.
(
sample: FloatTensor
timestep: typing.Union[float, torch.FloatTensor]
)
→
torch.FloatTensor
Scales the denoising model input by (sigma**2 + 1) ** 0.5 to match the K-LMS algorithm.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: typing.Union[float, torch.FloatTensor]
sample: FloatTensor
order: int = 4
return_dict: bool = True
)
→
~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
float) — current timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
order — coefficient for multi-step inference.
bool) — option for returning tuple rather than LMSDiscreteSchedulerOutput class
Returns
~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput or tuple
~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput if return_dict is True, otherwise a tuple.
When returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
Original implementation can be found here.
( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: typing.Optional[numpy.ndarray] = None skip_prk_steps: bool = False set_alpha_to_one: bool = False steps_offset: int = 0 )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
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.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
bool) —
allows the scheduler to skip the Runge-Kutta steps that are defined in the original paper as being required
before plms steps; defaults to False.
bool, default False) —
each diffusion step uses the value of alphas product at that step and at the previous one. For the final
step there is no previous alpha. When this option is True the previous alpha product is fixed to 1,
otherwise it uses the value of alpha at step 0.
int, default 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, as done in
stable diffusion.
Pseudo numerical methods for diffusion models (PNDM) proposes using more advanced ODE integration techniques, namely Runge-Kutta method and a linear multi-step method.
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details, see the original paper: https://arxiv.org/abs/2202.09778
(
sample: FloatTensor
*args
**kwargs
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
return_dict: bool = True
)
→
SchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
bool) — option for returning tuple rather than SchedulerOutput class
Returns
SchedulerOutput or tuple
SchedulerOutput if return_dict is True, otherwise a tuple. When
returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
This function calls step_prk() or step_plms() depending on the internal variable counter.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
return_dict: bool = True
)
→
~scheduling_utils.SchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
bool) — option for returning tuple rather than SchedulerOutput class
Returns
~scheduling_utils.SchedulerOutput or tuple
~scheduling_utils.SchedulerOutput if return_dict is
True, otherwise a tuple. When returning a tuple, the first element is the sample tensor.
Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple times to approximate the solution.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
return_dict: bool = True
)
→
~scheduling_utils.SchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
bool) — option for returning tuple rather than SchedulerOutput class
Returns
~scheduling_utils.SchedulerOutput or tuple
~scheduling_utils.SchedulerOutput if return_dict is
True, otherwise a tuple. When returning a tuple, the first element is the sample tensor.
Step function propagating the sample with the Runge-Kutta method. RK takes 4 forward passes to approximate the solution to the differential equation.
Original paper can be found here.
( num_train_timesteps: int = 2000 snr: float = 0.15 sigma_min: float = 0.01 sigma_max: float = 1348.0 sampling_eps: float = 1e-05 correct_steps: int = 1 )
Parameters
int) — number of diffusion steps used to train the model.
float) —
coefficient weighting the step from the model_output sample (from the network) to the random noise.
float) —
initial noise scale for sigma sequence in sampling procedure. The minimum sigma should mirror the
distribution of the data.
float) — maximum value used for the range of continuous timesteps passed into the model.
float) — the end value of sampling, where timesteps decrease progressively from 1 to
epsilon. —
int) — number of correction steps performed on a produced sample.
The variance exploding stochastic differential equation (SDE) scheduler.
For more information, see the original paper: https://arxiv.org/abs/2011.13456
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
(
sample: FloatTensor
timestep: typing.Optional[int] = None
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
( num_inference_steps: int sigma_min: float = None sigma_max: float = None sampling_eps: float = None )
Parameters
int) —
the number of diffusion steps used when generating samples with a pre-trained model.
float, optional) —
initial noise scale value (overrides value given at Scheduler instantiation).
float, optional) — final noise scale value (overrides value given at Scheduler instantiation).
float, optional) — final timestep value (overrides value given at Scheduler instantiation).
Sets the noise scales used for the diffusion chain. Supporting function to be run before inference.
The sigmas control the weight of the drift and diffusion components of sample update.
( num_inference_steps: int sampling_eps: float = None device: typing.Union[str, torch.device] = None )
Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
sample: FloatTensor
generator: typing.Optional[torch._C.Generator] = None
return_dict: bool = True
)
→
SdeVeOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
generator — random number generator.
bool) — option for returning tuple rather than SchedulerOutput class
Returns
SdeVeOutput or tuple
SdeVeOutput if
return_dict is True, otherwise a tuple. When returning a tuple, the first element is the sample tensor.
Correct the predicted sample based on the output model_output of the network. This is often run repeatedly after making the prediction for the previous timestep.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
generator: typing.Optional[torch._C.Generator] = None
return_dict: bool = True
)
→
SdeVeOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
generator — random number generator.
bool) — option for returning tuple rather than SchedulerOutput class
Returns
SdeVeOutput or tuple
SdeVeOutput if
return_dict is True, otherwise a tuple. When returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
Original implementation can be found here.
( num_train_timesteps: int = 1000 )
Improved Pseudo numerical methods for diffusion models (iPNDM) ported from @crowsonkb’s amazing k-diffusion library
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details, see the original paper: https://arxiv.org/abs/2202.09778
(
sample: FloatTensor
*args
**kwargs
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
return_dict: bool = True
)
→
~scheduling_utils.SchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
bool) — option for returning tuple rather than SchedulerOutput class
Returns
~scheduling_utils.SchedulerOutput or tuple
~scheduling_utils.SchedulerOutput if return_dict is
True, otherwise a tuple. When returning a tuple, the first element is the sample tensor.
Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple times to approximate the solution.
Original paper can be found here.
Score SDE-VP is under construction.
( num_train_timesteps = 2000 beta_min = 0.1 beta_max = 20 sampling_eps = 0.001 )
The variance preserving stochastic differential equation (SDE) scheduler.
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more information, see the original paper: https://arxiv.org/abs/2011.13456
UNDER CONSTRUCTION
Euler scheduler (Algorithm 2) from the paper Elucidating the Design Space of Diffusion-Based Generative Models by Karras et al. (2022). Based on the original k-diffusion implementation by Katherine Crowson. Fast scheduler which often times generates good outputs with 20-30 steps.
( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: typing.Optional[numpy.ndarray] = None )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
linear or scaled_linear.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
Euler scheduler (Algorithm 2) from Karras et al. (2022) https://arxiv.org/abs/2206.00364. . Based on the original k-diffusion implementation by Katherine Crowson: https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
(
sample: FloatTensor
timestep: typing.Union[float, torch.FloatTensor]
)
→
torch.FloatTensor
Scales the denoising model input by (sigma**2 + 1) ** 0.5 to match the Euler algorithm.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: typing.Union[float, torch.FloatTensor]
sample: FloatTensor
s_churn: float = 0.0
s_tmin: float = 0.0
s_tmax: float = inf
s_noise: float = 1.0
generator: typing.Optional[torch._C.Generator] = None
return_dict: bool = True
)
→
~schedulers.scheduling_utils.EulerDiscreteSchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
float) — current timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
float) —
float) —
float) —
float) —
torch.Generator, optional) — Random number generator.
bool) — option for returning tuple rather than EulerDiscreteSchedulerOutput class
Returns
~schedulers.scheduling_utils.EulerDiscreteSchedulerOutput or tuple
~schedulers.scheduling_utils.EulerDiscreteSchedulerOutput if return_dict is True, otherwise a
tuple. When returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
Ancestral sampling with Euler method steps. Based on the original (k-diffusion)[https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72] implementation by Katherine Crowson. Fast scheduler which often times generates good outputs with 20-30 steps.
( num_train_timesteps: int = 1000 beta_start: float = 0.0001 beta_end: float = 0.02 beta_schedule: str = 'linear' trained_betas: typing.Optional[numpy.ndarray] = None )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
linear or scaled_linear.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
Ancestral sampling with Euler method steps. Based on the original k-diffusion implementation by Katherine Crowson: https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
(
sample: FloatTensor
timestep: typing.Union[float, torch.FloatTensor]
)
→
torch.FloatTensor
Scales the denoising model input by (sigma**2 + 1) ** 0.5 to match the Euler algorithm.
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: typing.Union[float, torch.FloatTensor]
sample: FloatTensor
generator: typing.Optional[torch._C.Generator] = None
return_dict: bool = True
)
→
~schedulers.scheduling_utils.EulerAncestralDiscreteSchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned diffusion model.
float) — current timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
torch.Generator, optional) — Random number generator.
bool) — option for returning tuple rather than EulerAncestralDiscreteSchedulerOutput class
Returns
~schedulers.scheduling_utils.EulerAncestralDiscreteSchedulerOutput or tuple
~schedulers.scheduling_utils.EulerAncestralDiscreteSchedulerOutput if return_dict is True, otherwise
a tuple. When returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).
Original paper can be found here
( num_vec_classes: int num_train_timesteps: int = 100 alpha_cum_start: float = 0.99999 alpha_cum_end: float = 9e-06 gamma_cum_start: float = 9e-06 gamma_cum_end: float = 0.99999 )
Parameters
int) —
The number of classes of the vector embeddings of the latent pixels. Includes the class for the masked
latent pixel.
int) —
Number of diffusion steps used to train the model.
float) —
The starting cumulative alpha value.
float) —
The ending cumulative alpha value.
float) —
The starting cumulative gamma value.
float) —
The ending cumulative gamma value.
The VQ-diffusion transformer outputs predicted probabilities of the initial unnoised image.
The VQ-diffusion scheduler converts the transformer’s output into a sample for the unnoised image at the previous diffusion timestep.
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details, see the original paper: https://arxiv.org/abs/2111.14822
(
t: torch.int32
x_t: LongTensor
log_onehot_x_t: FloatTensor
cumulative: bool
)
→
torch.FloatTensor of shape (batch size, num classes - 1, num latent pixels)
Parameters
torch.LongTensor of shape (batch size, num latent pixels)) —
The classes of each latent pixel at time t.
torch.FloatTensor of shape (batch size, num classes, num latent pixels)) —
The log one-hot vectors of x_t
bool) —
If cumulative is False, we use the single step transition matrix t-1->t. If cumulative is True,
we use the cumulative transition matrix 0->t.
Returns
torch.FloatTensor of shape (batch size, num classes - 1, num latent pixels)
Each column of the returned matrix is a row of log probabilities of the complete probability transition matrix.
When non cumulative, returns self.num_classes - 1 rows because the initial latent pixel cannot be
masked.
Where:
q_n is the probability distribution for the forward process of the nth latent pixel.non-cumulative result (omitting logarithms):
cumulative result (omitting logarithms):
Returns the log probabilities of the rows from the (cumulative or non-cumulative) transition matrix for each
latent pixel in x_t.
See equation (7) for the complete non-cumulative transition matrix. The complete cumulative transition matrix is the same structure except the parameters (alpha, beta, gamma) are the cumulative analogs.
(
log_p_x_0
x_t
t
)
→
torch.FloatTensor of shape (batch size, num classes, num latent pixels)
Calculates the log probabilities for the predicted classes of the image at timestep t-1. I.e. Equation (11).
Instead of directly computing equation (11), we use Equation (5) to restate Equation (11) in terms of only forward probabilities.
Equation (11) stated in terms of forward probabilities via Equation (5):
Where:
p(x{t-1} | x_t) = sum( q(x_t | x{t-1}) q(x_{t-1} | x_0) p(x_0) / q(x_t | x_0) )
( num_inference_steps: int device: typing.Union[str, torch.device] = None )
Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
(
model_output: FloatTensor
timestep: torch.int64
sample: LongTensor
generator: typing.Optional[torch._C.Generator] = None
return_dict: bool = True
)
→
~schedulers.scheduling_utils.VQDiffusionSchedulerOutput or tuple
Parameters
torch.long) —
The timestep that determines which transition matrices are used.
x_t — (torch.LongTensor of shape (batch size, num latent pixels)):
The classes of each latent pixel at time t
generator — (torch.Generator or None):
RNG for the noise applied to p(x_{t-1} | x_t) before it is sampled from.
bool) —
option for returning tuple rather than VQDiffusionSchedulerOutput class
Returns
~schedulers.scheduling_utils.VQDiffusionSchedulerOutput or tuple
~schedulers.scheduling_utils.VQDiffusionSchedulerOutput if return_dict is True, otherwise a tuple.
When returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep via the reverse transition distribution i.e. Equation (11). See the
docstring for self.q_posterior for more in depth docs on how Equation (11) is computed.
DDPM-based inpainting scheduler for unsupervised inpainting with extreme masks. Intended for use with RePaintPipeline. Based on the paper RePaint: Inpainting using Denoising Diffusion Probabilistic Models and the original implementation by Andreas Lugmayr et al.: https://github.com/andreas128/RePaint
( 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: typing.Optional[numpy.ndarray] = None clip_sample: bool = True )
Parameters
int) — number of diffusion steps used to train the model.
float) — the starting beta value of inference.
float) — the final beta value.
str) —
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.
float) —
The weight of noise for added noise in a diffusion step. Its value is between 0.0 and 1.0 -0.0 is DDIM and
1.0 is DDPM scheduler respectively.
np.ndarray, optional) —
option to pass an array of betas directly to the constructor to bypass beta_start, beta_end etc.
str) —
options to clip the variance used when adding noise to the denoised sample. Choose from fixed_small,
fixed_small_log, fixed_large, fixed_large_log, learned or learned_range.
bool, default True) —
option to clip predicted sample between -1 and 1 for numerical stability.
RePaint is a schedule for DDPM inpainting inside a given mask.
~ConfigMixin takes care of storing all config attributes that are passed in the scheduler’s __init__
function, such as num_train_timesteps. They can be accessed via scheduler.config.num_train_timesteps.
~ConfigMixin also provides general loading and saving functionality via the save_config() and
from_config() functions.
For more details, see the original paper: https://arxiv.org/pdf/2201.09865.pdf
(
sample: FloatTensor
timestep: typing.Optional[int] = None
)
→
torch.FloatTensor
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep.
(
model_output: FloatTensor
timestep: int
sample: FloatTensor
original_image: FloatTensor
mask: FloatTensor
generator: typing.Optional[torch._C.Generator] = None
return_dict: bool = True
)
→
~schedulers.scheduling_utils.RePaintSchedulerOutput or tuple
Parameters
torch.FloatTensor) — direct output from learned
diffusion model.
int) — current discrete timestep in the diffusion chain.
torch.FloatTensor) —
current instance of sample being created by diffusion process.
torch.FloatTensor) —
the original image to inpaint on.
torch.FloatTensor) —
the mask where 0.0 values define which part of the original image to inpaint (change).
torch.Generator, optional) — random number generator.
bool) — option for returning tuple rather than
DDPMSchedulerOutput class
Returns
~schedulers.scheduling_utils.RePaintSchedulerOutput or tuple
~schedulers.scheduling_utils.RePaintSchedulerOutput if return_dict is True, otherwise a tuple. When
returning a tuple, the first element is the sample tensor.
Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion process from the learned model outputs (most often the predicted noise).