Extract values from a 1-D numpy array for a batch of indices. :param arr: the 1-D numpy array. :param timesteps: a tensor of indices into

Create a 1D, 2D, or 3D convolution module.

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.

Make a standard normalization layer. :param channels: number of input channels. :return: an nn.Module for normalization.

Create a linear module.

Take the mean over all non-batch dimensions.

Write the sequence of args, with no separators, to the console and output files (if you've configured an output file).

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

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

Defaults for image training.

Zero out the parameters of a module and return it.

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

Apply the model to get p(x_{t-1} | x_t), as well as a prediction of the initial x, x_0. :param model: the model, which takes

Compute the mean and variance of the diffusion posterior: q(x_{t-1} | x_t, x_0)

Diffuse the data for a given number of diffusion steps. In other words, sample from q(x_t | x_0). :param x_start: the initial

This one does fully convolutional inference. No sliding window

Use DDIM to sample from the model and yield intermediate samples from each timestep of DDIM. Same usage as p_sample_loop_prog

Dice coeff for batches

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 P

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`.

Create sinusoidal timestep embeddings. :param timesteps: a 1-D Tensor of N indices, one per batch element. These may b

A fast approximation of the cumulative distribution function of the standard normal.

Evaluate a function without caching intermediate activations, allowing for reduced memory at the expense of extra compute in the backward pas

If comm is provided, average all numerical stats across that comm

Convert the torso of the model to float16.

A counter for the `thop` package to count the operations in an attention operation. Meant to be used like: macs, params = thop.pr

Return the data prediction model (with corrector).

Defaults for image and classifier training.

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).

Copy model parameters into a (differently-shaped) list of full-precision parameters.

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

Return the noise prediction model.

Compute the KL divergence between two gaussians. Shapes are automatically broadcasted, so batches can be compared to scalars, among othe

Generate samples from the model and yield intermediate samples from each timestep of diffusion. Arguments are the same as p_s

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

directory is expected to contain some folder structure: if some subfolder contains only files, all of these

This one does fully convolutional inference. No sliding window

Get the prior KL term for the variational lower-bound, measured in bits-per-dim. This term can't be optimized, as it only dep

Get a term for the variational lower-bound. The resulting units are bits (rather than nats, as one might expect). This allows

Create a 1D, 2D, or 3D average pooling module.