Compute lambda_t = log(alpha_t) - log(sigma_t) of a given continuous-time label t in [0, T].

Compute sigma_t of a given continuous-time label t in [0, T].

Compute log(alpha_t) of a given continuous-time label t in [0, T].

Convert the model to the noise prediction model or the data prediction model.

Compute the intermediate time steps for sampling. Args: skip_type: A `str`. The type for the spacing of the time steps. We suppor

Compute the continuous-time label t in [0, T] of a given half-logSNR lambda_t.

Compute alpha_t of a given continuous-time label t in [0, T].

set new schedule, include but not limited betas, alphas, betas_cumprod, alphas_cumprod and register them into a buffer. Args:

DPM-Solver-1 (equivalent to DDIM) from time `s` to time `t`. Args: x: A pytorch tensor. The initial value at time `s`.

Expand the tensor `v` to the dim `dims`. Args: `v`: a PyTorch tensor with shape [N]. `dim`: a `int`. Returns: a

model load parameters Args: path (str): checkpoint path model (nn.Module): model instance strict (bool, optional): strict

Compute the sample at time `t_end` by DPM-Solver, given the initial `x` at time `t_start`. =========================================

Singlestep solver DPM-Solver-2 from time `s` to time `t`. Args: x: A pytorch tensor. The initial value at time `s`.

Return the data prediction model (with corrector).

Convert the continuous-time `t_continuous` (in [epsilon, T]) to the model input time. For discrete-time DPMs, we convert `t_continuou

A piecewise linear function y = f(x), using xp and yp as keypoints. We implement f(x) in a differentiable way (i.e. applicable for autograd).

a list of tensor like [ta, tb, tc, td, tf, te] -> [[ta, tb, tc], [td, tf, te]] when n is 3 and mode is 'time'; [[ta, td], [tb, td], [tc, te]]

Create a wrapper function for the noise prediction model. DPM-Solver needs to solve the continuous-time diffusion ODEs. For DPMs trained on discr

Multistep DPM-Solver with the order `order` from time `t_prev_list[-1]` to time `t`. Args: x: A pytorch tensor. The init

Return the noise prediction model.

Singlestep solver DPM-Solver-3 from time `s` to time `t`. Args: x: A pytorch tensor. The initial value at time `s`.

Compute the gradient of the classifier, i.e. nabla_{x} log p_t(cond | x_t).

Denoise at the final step, which is equivalent to solve the ODE from lambda_s to infty by first-order discretization.

The adaptive step size solver based on singlestep DPM-Solver. Args: x: A pytorch tensor. The initial value at time `t_T`

The dynamic thresholding method.

Apply element-wise weight and reduce loss between a pair of input and target.

train and valid function Args: train_dataset_path (str): _description_ valid_dataset_path (str): _description_ batch_size

Expand the tensor `v` to the dim `dims`. Args: `v`: a PyTorch tensor with shape [N]. `dim`: a `int`. Returns: a P

Get the order of each step for sampling by the singlestep DPM-Solver. We combine both DPM-Solver-1,2,3 to use all the function evalu

do a gradient clipping Args: params (tensor): model params mode (str, optional): 'value' or 'norm'. Defaults to 'value'.