Title: Parallel Sampling of Diffusion Models
Venue: NeurIPS 2023
Accepted: yes
Keywords: diffusion models

parallel sampling
Abstract: Diffusion models are powerful generative models but suffer from slow sampling, often taking 1000 sequential denoising steps for one sample. As a result, considerable efforts have been directed toward reducing the number of denoising steps, but these methods hurt sample quality. Instead of reducing the number of denoising steps (trading quality for speed), in this paper we explore an orthogonal approach: can we run the denoising steps in parallel (trading compute for speed)? In spite of the sequential nature of the denoising steps, we show that surprisingly it is possible to parallelize sampling via Picard iterations, by guessing the solution of future denoising steps and iteratively refining until convergence. With this insight, we present ParaDiGMS, a novel method to accelerate the sampling of pretrained diffusion models by denoising multiple steps in parallel. ParaDiGMS is the first diffusion sampling method that enables trading compute for speed and is even compatible with existing fast sampling techniques such as DDIM and DPMSolver. Using ParaDiGMS, we improve sampling speed by 2-4x across a range of robotics and image generation models, giving state-of-the-art sampling speeds of 0.2s on 100-step DiffusionPolicy and 14.6s on 1000-step StableDiffusion-v2 with no measurable degradation of task reward, FID score, or CLIP score.

Parallel Sampling of Diffusion Models

Abstract

Diffusion models are powerful generative models but suffer from slow sampling, often taking 1000 sequential denoising steps for one sample. As a result, considerable efforts have been directed toward reducing the number of denoising steps, but these methods hurt sample quality. Instead of reducing the number of denoising steps (trading quality for speed), in this paper we explore an orthogonal approach: can we run the denoising steps in parallel (trading compute for speed)? In spite of the sequential nature of the denoising steps, we show that surprisingly it is possible to parallelize sampling via Picard iterations, by guessing the solution of future denoising steps and iteratively refining until convergence. With this insight, we present ParaDiGMS, a novel method to accelerate the sampling of pretrained diffusion models by denoising multiple steps in parallel. ParaDiGMS is the first diffusion sampling method that enables trading compute for speed and is even compatible with existing fast sampling techniques such as DDIM and DPMSolver. Using ParaDiGMS, we improve sampling speed by 2-4x across a range of robotics and image generation models, giving state-of-the-art sampling speeds of 0.2s on 100-step DiffusionPolicy and 14.6s on 1000-step StableDiffusion-v2 with no measurable degradation of task reward, FID score, or CLIP score. 1

1 Introduction

Diffusion models [28, 9, 32] have demonstrated powerful modeling capabilities for image generation [34, 15, 24], molecular generation [38], robotic policies [12, 4], and other applications. The main limitation of diffusion models, however, is that sampling can be inconveniently slow. For example, the widely-used Denoising Diffusion Probabilistic Models (DDPMs) [9] can take 1000 denoising steps to generate one sample. In light of this, many works like DDIM [29] and DPMSolver [18] have proposed to improve sampling speed by reducing the number of denoising steps. Unfortunately, reducing the number of steps can come at the cost of sample quality.

We are interested in accelerating sampling of pretrained diffusion models without sacrificing sample quality. We ask the following question: rather than trading quality for speed, can we instead trade compute for speed? That is, could we leverage additional (parallel) compute to perform the same number of denoising steps faster? At first, this proposal seems unlikely to work, since denoising proceeds sequentially. Indeed, naïve parallelization can let us generate multiple samples at once ( improve throughput ), but generating a single sample with faster wall-clock time ( improving latency ) appears much more difficult.

We show that, surprisingly, it is possible to improve the sample latency of diffusion models by computing denoising steps in parallel. Our method builds on the idea of Picard iterations to guess the full denoising trajectory and iteratively refine until convergence. Empirically, we find that the number of iterations for convergence is much smaller than the number of steps. Therefore, by computing each iteration quickly via parallelization, we sample from the diffusion model much faster.

Our method ParaDiGMS (Parallel Diffusion Generative Model Sampling) is the first general method that allows for the tradeoff between compute and sampling speed of pretrained diffusion models. Remarkably, ParaDiGMS is compatible with classifier-free guidance [10] and with prior fast sampling methods [29, 18] that reduce the number of denoising steps. In other words, we present an orthogonal solution that can form combinations with prior methods (which we call ParaDDPM, ParaDDIM, ParaDPMSolver) to trade both compute and quality for speed.

We experiment with ParaDiGMS across a large range of robotics and image generation models, including Robosuite Square, PushT, Robosuite Kitchen, StableDiffusion-v2, and LSUN. Our method is strikingly consistent, providing an improvement across all tasks and all samplers (ParaDDPM, ParaDDIM, ParaDPMSolver) of around 2-4x speedup with no measurable decrease in quality on task reward, FID score, or CLIP score. For example, we improve the sample time of the 100-step action generation of DiffusionPolicy from 0.74s to 0.2s, and the 1000-step image generation of StableDiffusion-v2 on A100 GPUs from 50.0s to 14.6s. Our improvements also extend to few-step image generation, showing speedups for as low as 50-step DDIM. By enabling these faster sampling speeds without quality degradation, ParaDiGMS can enhance exciting applications of diffusion models such as real-time execution of diffusion policies or interactive generation of images.

2 Background

Diffusion models [28, 9] such as Denoising Diffusion Probabilistic Models (DDPM) were introduced as latent-variable models with a discrete-time forward diffusion process where q ( x 0 ) is the data distribution, α is a scalar function, with latent variables { x t : t ≤ T } defined as

By setting α ( T ) close to 0 , q ( x T ) converges to N ( 0 , I ) , allowing us to sample data x 0 by using a standard Gaussian prior and a learned inference model p θ ( x t -1 | x t ) . The inference model p θ is parameterized as a Gaussian with predicted mean and time-dependent variance σ 2 t , and can be used to sample data by sequential denoising, i.e., p θ ( x 0 ) = ∏ T t =1 p θ ( x t -1 | x t ) ,

Many works [32, 18] alternatively formulate diffusion models as a Stochastic Differential Equation (SDE) by writing the forward diffusion process in the form

with the standard Wiener process w t , where f and g are position-independent functions that can be appropriately chosen to match the transition distribution q ( x t | x 0 ) [18, 15]. These works use an important result from [2] that the reverse process of Eq. (2) takes on the form

where ¯ w t is the standard Wiener process in reverse time. This perspective allows us to treat the sampling process of DDPM as solving a discretization of the SDE where the DDPM inference model p θ can be used to compute an approximation p θ ( x t -1 | x t ) -x t of the drift term in Eq. (3).

Since the focus of this paper is on sampling from a pretrained diffusion model, we can assume p θ is given. For our purposes, we only need two observations about sampling from the reverse process in Eq. (3): we have access to an oracle that computes the drift at any given point, and the SDE has position-independent noise. We will use the latter observation in Section 3.

2.1 Reducing the number of denoising steps

DDPMtypically uses a T = 1000 step discretization of the SDE. These denoising steps are computed sequentially and require a full pass through the neural network p θ each step, so sampling can be extremely slow. As a result, popular works such as DDIM [29] and DPMSolver [18] have explored the possibility of reducing the number of denoising steps, which amounts to using a coarser discretization with the goal of trading sample quality for speed.

Empirically, directly reducing the number of steps of the stochastic sampling process of DDPM hurts sample quality significantly. Therefore many works [29, 32, 18] propose using an Ordinary Differential Equation (ODE) to make the sampling process more amenable to low-step methods. These works appeal to the probability flow ODE [20], a deterministic process with the property that the marginal distribution p ( x t ) at each time t matches that of the SDE, so in theory sampling from the probability flow ODE is equivalent to sampling from the SDE:

By sampling from the ODE instead of the SDE, works such as DDIM and DPMSolver (which have connections to numerical methods such as Euler and Heun) can reduce the quality degradation of few-step sampling (e.g., 50 steps).

As a summary, the current landscape of sampling from pretrained diffusion models is comprised of full-step DDPM or accelerated sampling techniques such as DDIM and DPMSolver that trade quality for speed by reducing the number of denoising steps.

Notation We write [ a, b ] to denote the set { a, a + 1 , . . . , b } and [ a, b ) to denote the set { a, a + 1 , . . . , b -1 } for b > a . We write x a : b to denote the set { x i : i ∈ [ a, b ) } . Since our focus is on sampling, in the rest of the paper we denote time as increasing for the reverse process.

3 Parallel computation of denoising steps

Rather than investigating additional techniques for reducing the number of denoising steps, which can lead to quality degradation, we look towards other approaches for accelerating sampling. In particular, we investigate the idea of trading compute for speed: can we accelerate sampling by taking denoising steps in parallel? We clarify that our goal is not to improve sample throughput - that can be done with naïve parallelization, producing multiple samples at the same time. Our goal is to improve sample latency - minimize the wall-clock time required for generating a single sample by solving the denoising steps for a single sample in parallel. Lowering sample latency without sacrificing quality can greatly improve the experience of using diffusion models, and enable more interactive and real-time generation applications.

Parallelizing the denoising steps, however, seems challenging due to the sequential nature of existing sampling methods. The computation graph has a chain structure (Fig. 1), so it is difficult to propagate information quickly down the graph. To make headway, we present the method of Picard iteration, a technique for solving ODEs through fixed-point iteration. An ODE is defined by a drift function s ( x , t ) with position and time arguments, and initial value x 0 . In the integral form, the value at time t can be written as

In other words, the value at time t must be the initial value plus the integral of the derivative along the path of the solution. This formula suggests a natural way of solving the ODE by starting with a guess of the solution { x k t : 0 ≤ t ≤ 1 } at initial iteration k = 0 , and iteratively refining by updating the value at every time t until convergence:

Under mild conditions on s , such as continuity in time and Lipschitz continuity in position as in the well-known Picard-Lindelöf theorem, the iterates form a convergent sequence, and by the Banach fixed-point theorem, they converge to the unique solution of the ODE with initial value x 0 [cf. 5]. To perform Picard iterations numerically, we can write the discretized form of Eq. (4) with step size 1 /T , for t ∈ [0 , T ] :

x

0

x

1

x

2

x

T

. . .

x

k

0

x

k

1

x

k

2

x

k

T

x

k

+1

0

x

k

+1

1

x

k

+1

2

x

k

+1

T

. . .

. . .

Examining the iterative update rule in Eq. (5), we see that an update at time t depends on all previous timesteps instead of just the previous timestep t -1 . This amounts to introducing skip dependencies in the computation graph (Fig. 2), which enables information to propagate quickly down the chain and accelerate sampling.

The key property of interest is that each Picard iteration can be parallelized by performing the expensive computations { s ( x k i , i T ) : i ∈ [0 , T ) } in parallel and then, with negligible cost, collecting their outputs into prefix sums. Given enough parallel processing power, the sampling time then scales with the number of iterations K until convergence, instead of the number of denoising steps T .

The number of iterations until convergence depends on the drift function s . More concretely, sequential evaluation can be written as a nested evaluation of functions x ⋆ t +1 = h t ( . . . h 2 ( h 1 ( x 0 ))) on the initial value x 0 where h i ( x ) = x + s ( x , i/T ) /T . If, for all timesteps, the drift at the true solution can be accurately obtained using the drift at the current guess, then the parallel evaluation will converge in one step.

Proposition 1. (Proof in Appendix A)

It is also easy to see that even in the worst case, exact convergence happens in K ≤ T iterations since the first k points x 0: k must equal the sequential solution x ⋆ 0: k after k iterations. In practice, the number of iterations until (approximate) convergence is typically much smaller than T , leading to a large empirical speedup.

The idea of Picard iterations is powerful because it enables the parallelization of denoising steps. Remarkably, Picard iterations are also fully compatible with prior methods for reducing the number of denoising steps. Recall that the drift term s ( x t , t/T ) /T can be written as h t ( x t ) -x t and approximated using Euler discretization as p θ ( x t +1 | x t ) -x t , but it can also be readily approximated using higher-order methods on p θ . In our experiments, we demonstrate the combination of the two axis of speedups to both reduce the number of denoising steps and compute the steps in parallel.

3.1 Practical considerations

Implementing Picard iteration on diffusion models presents a few practical challenges, the most important being that of GPU memory. Performing an iteration requires maintaining the entire array of points x 0: T over time, which can be prohibitively large to fit into GPU memory. To address this, we devise the technique of (mini-)batching which performs Picard iteration only on points x t : t + p inside a window of size p that can be chosen appropriately to satisfy memory constraints. Moreover, instead of iterating on x t : t + p until convergence of the full window before advancing to the next window, we use a sliding window approach to aggressively shift the window forward in time as soon as the starting timesteps in the window converge.

One other issue is the problem of extending Picard iteration to SDEs, since we rely on the determinism of ODEs to converge to a fixed point. Fortunately, since the reverse SDE (Eq. (3)) has positionindependent noise, we can sample the noise up-front and absorb these fixed noises into the drift of the (now deterministic) differential equation. Note that the resulting ODE is still Lipschitz continuous in position and continuous in time, guaranteeing the convergence of Picard iteration.

(a) Compute the drift of x k t : t + p on a batch window of size p = 4 , in parallel

(b) Update the values to x k +1 t : t + p us- ing the cumulative drift of points in the window

(c) Determine how far to slide the window forward, based on the er- ror ∥ x k +1 i - x k i ∥ 2 .

ot

batchwindow

batchwindow

batchwindow

Figure 3: ParaDiGMS algorithm: accelerating an ODE solver by computing the drift at multiple timesteps in parallel. During iteration k , we process in parallel a batch window of size p spanning timesteps [ t, t + p ) . The new values at a point x k +1 t + j are updated based on the value x k j at the left end of the window plus the cumulative drift 1 /T ∑ t + j -1 i = t s ( x k i , i/T ) of points in the window. We then slide the window forward until the error is greater than our tolerance, and repeat for the next iteration.

Finally, we need to choose a stopping criterion for the fixed-point iteration, picking a low tolerance to avoid degradations of sample quality. A low enough tolerance ensures that the outcome of parallel sampling will be close to the outcome of the sequential sampling process in total variation distance.

Proposition 2. (Proof in Appendix B) Assuming the iteration rule in Eq. (5) has a linear convergence rate with a factor ≥ 2 , using the tolerance ∥ x K t -x K -1 t ∥ 2 ≤ 4 ϵ 2 σ 2 t /T 2 ensures that samples of x K T are drawn from a distribution with total variation distance at most ϵ from the DDPM model distribution of Eq. (1) .

The above is based on a worst-case analysis, and in our experiments, we find that using a much more relaxed tolerance such as 2 1 D ∥ x k +1 i -x k i ∥ 2 ≤ τ 2 σ 2 i , with τ = 0 . 1 and D being the dimensionality of data, gives reliable speedups without any measurable degradation in sample quality.

In Algorithm 1 we present the complete procedure of ParaDiGMS, incorporating sliding window over a batch, up-front sampling of noise, and tolerance of Picard iterations (Fig. 3). The loop starting on Line 4 performs a sliding window over the batch of timesteps [ t, t + p ) in each iteration. Line 5 computes the drifts, which is the most compute-intensive part of the algorithm, but can be efficiently parallelized. Line 6 obtains their prefix sums in parallel to run the discretized Picard iteration update, and Lines 7-8 check the error values to determine how far forward we can shift the sliding window.

Algorithm 1: ParaDiGMS: parallel sampling via Picard iteration over a sliding window

Input: Diffusion model p θ with variances σ 2 t , tolerance τ , batch window size p , dimension D Output: A sample from p θ 1 t, k ← 0 , 0 2 z i ∼ N ( 0 , σ 2 i I ) ∀ i ∈ [0 , T ) // Up-front sampling of noise (for SDE) 3 x k 0 ∼ N ( 0 , I ) , x k i ← x k 0 ∀ i ∈ [1 , p ] // Sample initial condition from prior 4 while t < T do 5 y t + j ← p θ ( x k t + j , t + j ) -x k t + j ∀ j ∈ [0 , p ) // Compute drifts in parallel 6 x k +1 t + j +1 ← x k t + ∑ t + j i = t y i + ∑ t + j i = t z i ∀ j ∈ [0 , p ) // Discretized Picard iteration 7 error ←{ 1 D ∥ x k +1 t + j -x k t + j ∥ 2 : ∀ j ∈ [1 , p ) } // Store error value for each timestep 8 stride ← min ( { j : error j > τ 2 σ 2 j } ∪ { p } ) // Slide forward until we reach tolerance 9 x k +1 t + p + j ← x k +1 t + p ∀ j ∈ [1 , stride ] // Initialize new points that the window now covers 10 t ← t + stride , k ← k +1 11 p ← min( p, T -t ) 12 return x k T

The ParaDiGMS algorithm is directly compatible with existing fast sequential sampling techniques such as DDIM and DPMSolver, by swapping out the Euler discretization in Lines 5-6 for other

solvers, such as higher-order methods like Heun. As we see in our experiments, the combination of reducing the number of steps and solving the steps in parallel leads to even faster sample generation.

4 Experiments

We experiment with our method ParaDiGMS on a suite of robotic control tasks [4] including Square [41], PushT, Franka Kitchen [7], and high-dimensional image generation models including StableDiffusion-v2 [24] and LSUN Church and Bedroom [39]. We observe a consistent improvement of around 2-4x speedup relative to the sequential baselines without measurable degradation in sample quality as measured by task reward, FID score, or CLIP score.

4.1 Diffusion policy

Recently, a number of works have demonstrated the advantages of using diffusion models in robotic control tasks for flexible behavior synthesis or robust imitation learning on multimodal behavior [12, 4, 22, 36]. We follow the setup of DiffusionPolicy [4], which is an imitation learning framework that models action sequences. More specifically, DiffusionPolicy first specifies a prediction horizon h and a replanning horizon r . At each environment step l , DiffusionPolicy conditions on a history of observations and predicts a sequence of actions { a l : l + h } . Then, the policy executes the first r actions { a l : l + r } of the prediction. Therefore, for an episode of length L and scheduler with T steps, executing a full trajectory can take T × L/r denoising steps over a dimension of | a | × h , which can be inconveniently slow.

We examine our method on the Robosuite Square, PushT, and Robosuite Kitchen tasks. Each environment uses a prediction horizon of 16 , and replanning horizon 8 . The Square task uses statebased observations with a maximum trajectory length of 400 and a position-based action space of dimensionality 7 . This means the diffusion policy takes 50 samples per episode, with each sample being a series of denoising steps over a joint action sequence of dimension 112 . The PushT task also uses state-based observations and has a maximum trajectory length of 300 and action space of 2 , which results in 38 samples with denoising steps over a joint action sequence of dimension 32 . Lastly, the Kitchen task uses vision-based observations and has a maximum trajectory length of 1200 with an action space of 7 , giving 150 samples per episode and denoising steps over a joint action sequence of dimensionality 112 . For all three tasks, we use a convolution-based architecture.

The DDPM scheduler in DiffusionPolicy [4] uses 100 step discretization, and the DDIM/DPMSolver schedulers use 15 step discretization. For example, a trajectory in the Kitchen task requires 1200 / 8 = 150 samples, which amounts to 150 × 100 = 15000 denoising steps over an action sequence of dimensionality 112 with the DDPM scheduler.

In Table 1, we present results on DDPM, DDIM, DPMSolver, and their parallel variants (ParaDDPM, ParaDDIM, ParaDPMSolver) when combined with ParaDiGMS. We plot the model evaluations (number of calls to the diffusion model p θ ), the task reward, and the sampling speed reported in time per episode. Although parallelization increases the total number of necessary model evaluations, the sampling speed is more closely tied to the number of parallel iterations, which is much lower. We see that ParaDDPM gives a speedup of 3 . 7 x, ParaDDIM gives a speedup of 1 . 6 x, and ParaDPMSolver gives a speedup of 1 . 8 x, without a decrease in task reward. Table 2 presents similar findings on the PushT task, where we see speedups on all three methods with up to 3 . 9 x speedup on ParaDDPM.

The final robotics task we study is FrankaKitchen, a harder task with predicted action sequences of dimension 112 and an episode length of 1200. In Table 3 we notice some decline in performance when sampling with a reduced number of steps using DDIM and DPMSolver. On the other hand, ParaDDPM is able to maintain a high task reward. Similar to before, ParaDiGMS consistently achieves a speedup across all 3 sampling methods, giving a speedup of 3 . 4 x with ParaDDPM, 1 . 8 x with ParaDDIM, and 2 . 0 x with ParaDPMSolver. These improvements translate to a significant decrease in the time it takes to roll out an episode in the Kitchen task from 112s to 33.3s.

4.2 Diffusion image generation

Next, we apply parallel sampling to diffusion-based image generation models, both for latent-space and pixel-space models. For latent-space models, we test out StableDiffusion-v2 3 [26, 24], which generates 768x768 images using a diffusion model on a 4x96x96 latent space. For pixel-space models, we study pretrained models on LSUN Church 4 /Bedroom 5 from Huggingface [9, 35], which run a diffusion model directly over the 3x256x256 pixel space.

4.2.1 Latent-space diffusion models

Even with the larger image models, there is no issue fitting a batch window size of 20 on a single GPU for parallelization. However, the larger model requires more compute bandwidth, so the parallel efficiency quickly plateaus as the batch window size increases, as the single GPU becomes bottlenecked by floating-point operations per second (FLOPS). Therefore, for image models, we leverage multiple GPUs to increase FLOPS and improve the wall-clock sampling speed.

In Fig. 4 we examine the net speedup of ParaDDPM relative to DDPM on StableDiffusion-v2 using 1000-step diffusion on A100 GPUs. The net speedup is determined by the interplay between algorithm inefficiency and hardware efficiency . Algorithm inefficiency refers to the relative number of model evaluations of ParaDDPM compared to DDPM, which arises from the parallel algorithm taking multiple iterations until convergence. We see in Fig. 4e that as the batch window size grows, ParaDDPM can require 2-3x more model evaluations. On the other hand, hardware efficiency refers to the relative empirical speedup of performing a batch of model evaluations. For example, in Fig. 4e we see that evaluating a batch window size of 80 on 4 GPUs ( 20 per GPU) is roughly 5 x faster than performing 80 model evaluations sequentially. In Fig. 4f, we divide the hardware efficiency by the

9

8

xixxxxixlxix

7

hardware efficiency

6

5

4

3

algorithm

2

inefficiency

-X-

-X-

-X-

1gpus

2gpus

3gpus

-×-

-×-

-X-

6gpus

5gpus

7gpus

1

-X-

4gpus

-X-

8gpus

0

20

40

60

80

100

120

140

160

batchwindowsize

3.0

2.5

net speedup

2.0

1.5

normalized

1.0

inefficiency

algorithm

-X-

-X-

-X-

3gpus

1gpus

2gpus

-X-

-X-

6gpus

7gpus

-X-

4gpus

-X-

8gpus

0.5

0

20

40

60

80

100

120

140

160

batch window size

Figure 4: StableDiffusion-v2 generating text-conditioned 768x768 images by running ParaDDPM over a 4x96x96 latent space for 1000 steps, on A100 GPUs. In Fig. 4e algorithm inefficiency in gray denotes the relative number of model evaluations required as the parallel batch window size increases. The colored lines denote the hardware efficiency provided by the multi-GPUs. As the batch window size increases, the hardware efficiency overtakes the algorithm inefficiency. In Fig. 4f we normalize the algorithm inefficiency to 1 , to show the net wall-clock speedup of parallel sampling.

algorithm inefficiency to obtain the net relative speedup of ParaDDPM over DDPM. We observe over 3 x speedup by using a batch window size of 80 spread across 8 A100s. Finally, in Table 4 we verify that ParaDiGMS increases sampling speed for ParaDDPM, ParaDDIM, and ParaDPMSolver without degradation in sample quality as measured by CLIP score [8] on ViT-g-14 [23, 11].

One important consideration is that the algorithm inefficiency is agnostic to the choice of GPU. Therefore, as the parallel efficiency of GPUs in the future improve for large batch window sizes, we will see an even larger gap between hardware efficiency and algorithm inefficiency. With enough hardware efficiency, the wall-clock time of sampling will be limited only by the number of parallel iterations, leading to much larger net speedup. For example, observe that in Table 4 the number of parallel iterations of ParaDDPM is 20 x smaller than the number of sequential steps.

4.2.2 Pixel-space diffusion models

Next, we test out ParaDiGMS on pretrained diffusion models on LSUN Church and Bedroom, which perform diffusion directly on a 3x256x256 pixel space. In Fig. 5 in Appendix D, we plot the net speedup of 1000-step ParaDDPM by dividing the hardware efficiency by the algorithm inefficiency. We observe a similar trend of over 3 x speedup when using multiple GPUs. Finally, we verify in Table 5 that ParaDiGMS maintains the same sample quality as the baseline methods as measured by FID score on 5000 samples of LSUN Church 6 .

We highlight that 500-step DDIM gives a noticeably worse FID score than 1000-step DDPM, whereas using ParaDDPM allows us to maintain the same sample quality as DDPM while accelerating sampling (to be two times faster than 500-step DDIM). The ability to generate an image without quality degradation in 6.1s as opposed to 24.0s can significantly increase the viability of interactive image generation for many applications.

4.3 Related work

Apart from DDIM [29] and DPMSolver [18], there are a number of other fast sampling techniques for pretrained diffusion models [14, 17, 19, 40]. Most of these techniques are based on higher-order ODE-solving and should also be compatible with parallelization using ParaDiGMS. Other lines of work focus on distilling a few-step model [25, 21, 30] or learning a sampler [37], but these methods are more restrictive as they require additional training.

Besides diffusion models, many works have studied accelerating the sampling of autoregressive models using various approaches such as parallelization [33, 31], distillation [13], quantization [6], or rejection sampling [3, 16]. Of particular note is [31], which samples from autoregressive models by iterating on a system of equations until convergence. While these methods are not immediately applicable to diffusion models due to the differences in computational structure and inference efficiency of autoregressive models, there may be potential for further investigation.

Parallelization techniques similar to Picard iteration have been explored in theoretical works for sampling from log-concave [27] and determinantal distributions [1]. Our work is the first application of parallel sampling on diffusion models, enabling a new axis of trading compute for speed.

5 Conclusion

Limitations Since our parallelization procedure requires iterating until convergence, the total number of model evaluations increases relative to sequential samplers. Therefore, our method is not suitable for users with limited compute who wish to maximize sample throughput. Nevertheless, sample latency is often the more important metric. Trading compute for speed with ParaDiGMS

makes sense for many practical applications such as generating images interactively, executing robotic policies in real-time, or serving users who are insensitive to the cost of compute.

Our method is also an approximation to the sequential samplers since we iterate until the errors fall below some tolerance. However, we find that using ParaDiGMS with the reported tolerances results in no measurable degradations of sample quality in practice across a range of tasks and metrics. In fact, on more difficult metrics such as FID score on LSUN Church, ParaDDPM gives both higher sample quality and faster sampling speed than 500-step DDIM.

Discussion We present ParaDiGMS, the first accelerated sampling technique for diffusion models that enables the trade of compute for speed. ParaDiGMS improves sampling speed by using the method of Picard iterations, which computes multiple denoising steps in parallel through iterative refinement. Remarkably, ParaDiGMS is compatible with existing sequential sampling techniques like DDIM and DPMSolver, opening up an orthogonal axis for optimizing the sampling speed of diffusion models. Our experiments demonstrate that ParaDiGMS gives around 2-4x speedup over existing sampling methods across a range of robotics and image generation models, without sacrificing sample quality. As GPUs improve, the relative speedup of ParaDiGMS will also increase, paving an exciting avenue of trading compute for speed that will enhance diffusion models for many applications.

6 Acknowledgments

This research was supported in part by NSF (#1651565, #2045354, #2125511), ARO (W911NF-21-10125), ONR (N00014-23-1-2159, N00014-22-1-2293), CZ Biohub, HAI.

References

Nima Anari, Yizhi Huang, Tianyu Liu, Thuy-Duong Vuong, Brian Xu, and Katherine Yu. Parallel discrete sampling via continuous walks. In STOC '23: 55th Annual ACM SIGACT Symposium on Theory of Computing . ACM, 2023.

Brian DO Anderson. Reverse-time diffusion equation models. Stochastic Processes and their Applications , 12(3):313-326, 1982.

Charlie Chen, Sebastian Borgeaud, Geoffrey Irving, Jean-Baptiste Lespiau, Laurent Sifre, and John Jumper. Accelerating large language model decoding with speculative sampling. arXiv preprint arXiv:2302.01318 , 2023.

Cheng Chi, Siyuan Feng, Yilun Du, Zhenjia Xu, Eric Cousineau, Benjamin Burchfiel, and Shuran Song. Diffusion policy: Visuomotor policy learning via action diffusion. arXiv preprint arXiv:2303.04137 , 2023.

Earl A Coddington, Norman Levinson, and T Teichmann. Theory of ordinary differential ˙ equations. Physics Today , 9(2):18, 1956.

Tim Dettmers, Mike Lewis, Younes Belkada, and Luke Zettlemoyer. Llm. int8 (): 8-bit matrix multiplication for transformers at scale. arXiv preprint arXiv:2208.07339 , 2022.

Abhishek Gupta, Vikash Kumar, Corey Lynch, Sergey Levine, and Karol Hausman. Relay policy learning: Solving long-horizon tasks via imitation and reinforcement learning. arXiv preprint arXiv:1910.11956 , 2019.

Jack Hessel, Ari Holtzman, Maxwell Forbes, Ronan Le Bras, and Yejin Choi. Clipscore: A reference-free evaluation metric for image captioning. arXiv preprint arXiv:2104.08718 , 2021.

Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems , 33:6840-6851, 2020.

Jonathan Ho and Tim Salimans. Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598 , 2022.

Gabriel Ilharco, Mitchell Wortsman, Ross Wightman, Cade Gordon, Nicholas Carlini, Rohan Taori, Achal Dave, Vaishaal Shankar, Hongseok Namkoong, John Miller, Hannaneh Hajishirzi, Ali Farhadi, and Ludwig Schmidt. Openclip, July 2021.

Michael Janner, Yilun Du, Joshua B. Tenenbaum, and Sergey Levine. Planning with diffusion for flexible behavior synthesis. In International Conference on Machine Learning, ICML 2022 , 2022.

Xiaoqi Jiao, Yichun Yin, Lifeng Shang, Xin Jiang, Xiao Chen, Linlin Li, Fang Wang, and Qun Liu. Tinybert: Distilling bert for natural language understanding. arXiv preprint arXiv:1909.10351 , 2019.

Alexia Jolicoeur-Martineau, Ke Li, Rémi Piché-Taillefer, Tal Kachman, and Ioannis Mitliagkas. Gotta go fast when generating data with score-based models. arXiv preprint arXiv:2105.14080 , 2021.

Diederik Kingma, Tim Salimans, Ben Poole, and Jonathan Ho. Variational diffusion models. Advances in neural information processing systems , 34:21696-21707, 2021.

Yaniv Leviathan, Matan Kalman, and Yossi Matias. Fast inference from transformers via speculative decoding. In International Conference on Machine Learning, ICML 2023 , 2023.

Luping Liu, Yi Ren, Zhijie Lin, and Zhou Zhao. Pseudo numerical methods for diffusion models on manifolds. In The Tenth International Conference on Learning Representations, ICLR 2022 , 2022.

Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. Dpm-solver: A fast ode solver for diffusion probabilistic model sampling in around 10 steps. arXiv preprint arXiv:2206.00927 , 2022.

Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. Dpmsolver++: Fast solver for guided sampling of diffusion probabilistic models. arXiv preprint arXiv:2211.01095 , 2022.

Dimitra Maoutsa, Sebastian Reich, and Manfred Opper. Interacting particle solutions of fokker-planck equations through gradient-log-density estimation. Entropy , 22(8):802, 2020.

Chenlin Meng, Ruiqi Gao, Diederik P Kingma, Stefano Ermon, Jonathan Ho, and Tim Salimans. On distillation of guided diffusion models. arXiv preprint arXiv:2210.03142 , 2022.

Tim Pearce, Tabish Rashid, Anssi Kanervisto, Dave Bignell, Mingfei Sun, Raluca Georgescu, Sergio Valcarcel Macua, Shan Zheng Tan, Ida Momennejad, Katja Hofmann, et al. Imitating human behaviour with diffusion models. arXiv preprint arXiv:2301.10677 , 2023.

Alec Radford, Jong Wook Kim, Chris Hallacy, A. Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision. In ICML , 2021.

Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn Ommer. Highresolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition , pages 10684-10695, 2022.

Tim Salimans and Jonathan Ho. Progressive distillation for fast sampling of diffusion models. arXiv preprint arXiv:2202.00512 , 2022.

Christoph Schuhmann, Romain Beaumont, Richard Vencu, Cade W Gordon, Ross Wightman, Mehdi Cherti, Theo Coombes, Aarush Katta, Clayton Mullis, Mitchell Wortsman, Patrick Schramowski, Srivatsa R Kundurthy, Katherine Crowson, Ludwig Schmidt, Robert Kaczmarczyk, and Jenia Jitsev. LAION-5b: An open large-scale dataset for training next generation image-text models. In Thirty-sixth Conference on Neural Information Processing Systems Datasets and Benchmarks Track , 2022.

Ruoqi Shen and Yin Tat Lee. The randomized midpoint method for log-concave sampling. Advances in Neural Information Processing Systems , 32, 2019.

Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning , pages 2256-2265. PMLR, 2015.

Jiaming Song, Chenlin Meng, and Stefano Ermon. Denoising diffusion implicit models. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021 , 2021.

Yang Song, Prafulla Dhariwal, Mark Chen, and Ilya Sutskever. Consistency models. arXiv preprint arXiv:2303.01469 , 2023.

Yang Song, Chenlin Meng, Renjie Liao, and Stefano Ermon. Accelerating feedforward computation via parallel nonlinear equation solving. In International Conference on Machine Learning , pages 9791-9800. PMLR, 2021.

Yang Song, Jascha Sohl-Dickstein, Diederik P. Kingma, Abhishek Kumar, Stefano Ermon, and Ben Poole. Score-based generative modeling through stochastic differential equations. In 9th International Conference on Learning Representations, ICLR 2021 , 2021.

Mitchell Stern, Noam Shazeer, and Jakob Uszkoreit. Blockwise parallel decoding for deep autoregressive models. Advances in Neural Information Processing Systems , 31, 2018.

Arash Vahdat, Karsten Kreis, and Jan Kautz. Score-based generative modeling in latent space. Advances in Neural Information Processing Systems , 34:11287-11302, 2021.

Patrick von Platen, Suraj Patil, Anton Lozhkov, Pedro Cuenca, Nathan Lambert, Kashif Rasul, Mishig Davaadorj, and Thomas Wolf. Diffusers: State-of-the-art diffusion models. https: //github.com/huggingface/diffusers , 2022.

Hsiang-Chun Wang, Shang-Fu Chen, and Shao-Hua Sun. Diffusion model-augmented behavioral cloning. arXiv preprint arXiv:2302.13335 , 2023.

Daniel Watson, William Chan, Jonathan Ho, and Mohammad Norouzi. Learning fast samplers for diffusion models by differentiating through sample quality. In International Conference on Learning Representations , 2022.

Minkai Xu, Lantao Yu, Yang Song, Chence Shi, Stefano Ermon, and Jian Tang. Geodiff: A geometric diffusion model for molecular conformation generation. arXiv preprint arXiv:2203.02923 , 2022.

Fisher Yu, Ari Seff, Yinda Zhang, Shuran Song, Thomas Funkhouser, and Jianxiong Xiao. Lsun: Construction of a large-scale image dataset using deep learning with humans in the loop. arXiv preprint arXiv:1506.03365 , 2015.

Qinsheng Zhang, Molei Tao, and Yongxin Chen. gddim: Generalized denoising diffusion implicit models. 2023.

Yuke Zhu, Josiah Wong, Ajay Mandlekar, Roberto Martín-Martín, Abhishek Joshi, Soroush Nasiriany, and Yifeng Zhu. robosuite: A modular simulation framework and benchmark for robot learning. In arXiv preprint arXiv:2009.12293 , 2020.

A Proof of exact convergence

Proof of Proposition 1. Assume by induction that x k +1 t = x ⋆ t . Then

B Total variation analysis

Proof of Proposition 2. A linear convergence rate with factor ≥ 2 ensures our error from the solution x ⋆ t given by sequential sampling at each timestep t is bounded by the chosen tolerance:

Then, for each timestep t , since the inference model samples from a Gaussian with variance σ 2 t , we can bound the total variation distance:

Finally, we make use of the data processing inequality, that d TV ( f ( P ) , f ( Q )) ≤ d TV ( P, Q ) , so the total variation distance d t between the sample and model distribution after t timesteps does not increase when transformed by p θ . Then by the triangle inequality, we get that d t ≤ d t -1 + ϵ/T . giving a total variation distance d T of at most Tϵ/T = ϵ for the final timestep T .

C Parallel Computation on Multiple GPUs

We experimented with two different approaches to implementing parallel computation on multiple GPUs in PyTorch: 1) using torch.nn.DataParallel and 2) using torch.multiprocessing . DataParallel is very easy to implement, but performed more poorly than multiprocessing. For multiprocessing, we use a producer/consumer design where we spawn a single producer process on GPU 0 to run the main loop in Algorithm 1, and N consumer processes (one for each of the N GPUs) to run Line 5 of Algorithm 1 in parallel. Empirically, this worked better than dedicating the producer process with its own GPU and using only N -1 consumer processes, since the producer process requires very little GPU resources.

D Additional experiments

D.1 LSUN Church and LSUN Bedroom

In Fig. 5 we plot wallclock speedup of ParaDDPM as a function of batch window size and number of GPUs on LSUN Church and LSUN Bedroom. These experiments on LSUN show a similar trend as the experiments on StableDiffusion-v2 in Fig. 4f.

Netspeedup of ParaDDPM on LSUN church,A100

3.0

2.5

net speedup

2.0

1.5

normalized

algorithm

inefficiency

1.0

-X-

1gpus

5gpus

-×-

-×-

2gpus

3gpus

-X-7gpus

-X-

6gpus

0.5

-X-

4gpus

-X-

8gpus

0

20

40

60

80

100

120

140

160

batchwindowsize

Net speedup of ParaDDPM on LSUN bedroom,A100

3.5

*xx-x-x

3.0

net speedup

2.5

2.0

1.5

normalized

algorithm

inefficiency

-X=

1gpus

-X-5

5gpus

1.0

美

-X-

-X-

3gpus

2gpus

-X-

6gpus

7gpus

0.5

-X-

4gpus

-X-

0

20

40

60

80

100

120

140

160

batchwindowsize

(b) LSUN Bedroom, over 3x net wall clock speedup with 1000-step ParaDDPM using DataParallel

D.2 Ablation

In Table 6, we run an ablation study on the tolerance parameter τ for 200-step ParaDDIM. A lower tolerance means the algorithm takes more parallel iterations and attains better sample quality, whereas a higher tolerance means the algorithm slides the batch window forward more aggressively leading to fewer iterations and faster sampling. We see in Table 6 that for 200-step ParaDDIM on StableDiffusion-v2, a good choice of τ is 1e-1. Lower tolerance levels give less speedup without noticeable increase in CLIP score, and higher tolerance levels exhibit a drop in CLIP score.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper introduces a new method for speeding up (reduced latency) sampling of diffusion models by sampling all time steps in parallel from some initialization and then iterating this procedure until convergence (Picard Iteration). Modifications are made for implementation efficiency such as a sliding window. The method is evaluated on control tasks and large scale image datasets with a consistent reduction in latency at the expense of increased compute being reported.\n\nSTRENGTHS:\nThis paper is very good. The problem being tackled is highly significant and I think the approach will be widely used to easily achieve a reduction in latency when extra compute is available. The method is clearly presented with a nice bit of theoretical analysis. The experiments on practically releveant datasets clearly show the benefits of the method. I highly encourage acceptance.\n\nWEAKNESSES:\nI think it would have been nice to pick a suitably small problem and fully explore the compute/latency tradeoff by varying the window size. I appreciate the current experiment in Figure 4 which does nicely show this trade-off in this compute intensive regime however the picture is slightly obscured by the necessity of also considering GPU flop/s saturation (which is an important consideration in its own right I agree). I think a simpler experiment where you can vary the window size all the way up to the number of denoising steps would benefit the paper where we can see a potential 20x reduction in latency if DDPM is integrated with 1000 steps and the Picard iterations converge in around 50 steps.\n\nFor the experiments on StableDiffusion, it is not clear to what extent the method's benefits extend into the very low model evaluation regime. DPMSolver should be able to go to very few model evaluations and retain decent quality, in this regime, how does your method compare? It is ok if the model speedup is less in this case, but it would be good to know the extent to which the method can provide benefits.\n\nI think it would be good to stick with the terminology batch window size as you go through the experiments. When getting to section 4.2.1 it is a little confusing to start talking about batch sizes which may imply that you are generating entirely independent trajectories in parallel but I assume you still mean the batch containing the points in the window.\n\nEdit after rebuttal: I have read the author's response and my concerns have been addressed. I will keep my score of 8.\n\nQUESTIONS:\nIn proposition 2, how realistic is the assumption of the convergence rate of the Picard iterations in the context of integrating the probability flow ODE from a trained diffusion model?\n\nThis has been investigated somewhat between the two experiments but what would you say is the interaction between the number of Picard iterations and the number of steps used to integrate the ODE. Do you believe there could be any relation where more steps could be helpful to reduce the number of total Picard iterations or are these completely orthogonal quantities?\n\nLIMITATIONS:\nThe method is obviously more expensive than other diffusion models due to all steps being taken in parallel but this trade-off is well explained. Further, as explained above, the limits of when the method does not actually provide a speedup could have been better investigated.", "TITLE": "Official Review", "RECOMMENDATION": 8, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-04"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nInstead of reducing the number of denoising steps, the paper proposes to  parallelize diffsuion denoising sampling via Picard iterations, by guessing the solution of future denoising steps and iteratively refining until convergence, which trades compute for speed. The authors then present ParaDiGMS to accelerate the sampling of pretrained diffusion models by denoising multiple steps in parallel and verify its effectiveness.\n\nSTRENGTHS:\n- The idea is interesting and may promote another way for accelerated sampling.\n- The procedure of Algorithm is clear.\n\nWEAKNESSES:\nIn total, I think there are still many problems for the paper. Please refer to the questions.\n\nQUESTIONS:\n**Q1**:  Some notations may be a bit confusing, since the $x_T$ is always used to represent the initial noise of diffusion and the authors use $x_0$ to represent the initial point.\n\n**Q2**: For Algorithm 1, given the same denoising steps $T$, the proposed method is essentially similar to the existing techniques such as PNDM, DPMSolver. The existing high-order techniques should also cache the predicted score in previous time step, while the proposed method compute all the predicted score in a small window and use them for next selected window.\n\n**Q3**: The number of model evaluations: For all the tables, do you choose a different $T$ and use more parallel iterations compared to the baseline to match the sampling performance? If so, what is the value of $T$ ? If I am not wrong, $T = Model Eval / Para Iter$ ? The details are not clear. \n\n**Q4**: Following the prior question, how about setting a same $T$? Can parallel sampling improve the performance (e.g. FID)? This results could be important. If the performance remain the same, people can directly use a smaller denoising step $T$.\n\n**Q5**:  For image generation,  does $batch size = 80$ mean the author uses a batch window size of $80$?\n\n**Q6**: The evaluation results of image generation are not sufficient. How about the commonly-used FID for stable-diffusion? And more qualitative results should be shown and analysed.\n\n**Q7**: The algorithm seems not practical. As the authors said, this method may consume more resources. However, **Q4** is not clear. If the performance remain the same, more resources should be used to maximize sample throughput instead of parallel computing.\n\n**Q8**: Related works should discuss more parallelization techniques and the differences of between the proposed method and similar parallelization techniques.\n\nLIMITATIONS:\nThe authors have adequately addressed the limitations.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper proposes an approach for speeding up sampling of diffusion models using Picard iterations. Multiple time steps in the sample process are predicted in parallel, iteratively refining until converging. Rather than refining all time steps at once which would not be practical, a sliding window approach is used: points in the window are refined then the window is moved once the later time steps have converged. Experimentally this approach is tested on diffusion policy learning and image generation benchmarks, where it is shown to provide substantial speedup over sequential sampling methods, while achieving comparable sample quality.\n\nSTRENGTHS:\n- Using Picard iterations to speed up diffusion model sampling makes sense and is useful in many low latency scenarios such as image editing.\n- Showing that in the worst case, the approach will converge faster at least as fast as sequential sampling is nice (Lines 127-137). Similarly, providing tolerance bounds is useful (Lines 161-164).\n- A good set of experiments/ablations on a variety of benchmarks are provided. The approach is clearly shown to be faster than sequential approaches, while providing similar quality samples.\n- The approach is tested with multiple diffusion samplers, including the recent DPMSolver, showing that it can provide speedup even to already fast solvers.\n\nWEAKNESSES:\n- It is mentioned that a more relaxed tolerance value can be used when determining convergence (line 166). It would be useful to see the effect of that value on sampling times/image quality.\n- Currently multiple GPUs are required to achieve net speedup on Stable Diffusion (Figure 4f).\n- The approach is only useful for reducing latency; if generating lots of samples, then sampling batches sequentially is more efficient. However, as mentioned in the strengths, there are many applications where this is useful.\n\nQUESTIONS:\n- In Algorithm 1 on line 9, new points are initialised from the latest point in the window. Would it make more sense to initialise the values based on the prediction of $x_0$?\n- What practically is the impact of using different tolerance values?\n\nLIMITATIONS:\nLimitations are well discussed in section 4.2.1 and section 5. It’s also worth noting that due to the extra compute, this approach will use more energy so has a negative environmental impact.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors propose a technique to reduce the time taken to sample from a diffusion model at the expense of using more FLOPs. Roughly speaking, the authors parallelize sampling by \"guessing\" xt at numerous values of t simultaneously, then computing the score function for each of these values of xt in parallel, and then repeating to refine the estimate of each xt over multiple steps.\n\nSTRENGTHS:\n- The paper is clearly written. \n- The proposed method is novel.\n- The proposed method is practically useful in situations where having low latency is important (e.g. iterative human-in-the-loop image generation).\n- The experiments are thorough, showing speed-ups on a range of domains and even showing speedups when efficient samplers like DPMSolver are used.\n\nWEAKNESSES:\nOverall I am satisfied that this paper makes a tangible contribution. I have a couple of questions though about certain scenarios in which it is not immediately clear that this method is useful.\n- I would be interested to see the performance of the latent image generation when less steps are used. E.g. for Stable diffusion (https://github.com/CompVis/stable-diffusion), the given example command \"python scripts/txt2img.py --prompt \"a photograph of an astronaut riding a horse\" --plms \" produces good images in only 50 steps, which is much less than the 200 used in Section 4.2.1. Does the proposed method still provide a gain in this setting?\n- How does this method interact with other techniques to speed up sampling like progressive distillation (https://arxiv.org/abs/2202.00512)? I appreciate that one benefit of the proposed method is that it avoids the need to have any sort of \"distillation\" training phase, but can the proposed method provide additional advantages when used in combination with a \"progressively distilled\" model?\n\nQUESTIONS:\nSee above.\n\nLIMITATIONS:\nThe limitations are adequately addressed.", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-07"}

comments: SUMMARY:
Naive parallelization can let us generate multiple samples which improves throughput. However, the wall-clock time remains the same. To reduce the wall-clock time during diffusion model sampling, this paper proposes ParaDiGMS, a parallel sampling method of diffusion models based on Picard Iteration which improves latency. ParaDiGMS is compatible with classifier-free guidance and prior fast sampling methods. The experiment results show that ParaDiGMS can achieve a speedup without quality degradation.

STRENGTHS:
1. The authors provide a theoretical guarantee and error analysis of the proposed method.

2. The paper is motivated by the classical Picard Iteration which brings new ideas to the diffusion sampling community.

3. The paper is easy to follow and overall well-written which helps the reviewer understand the content.

4. The experiment results show that it achieves a speedup with no measurable decrease in quality.

WEAKNESSES:
The applicability of the proposed method is limited to certain situations. The total evaluations of ParaDiGMS are approximately twice that of the baseline method according to the experiments. Therefore, the proposed method may not be suitable for situations where maximizing sample throughput is a priority.

QUESTIONS:
In the section on experiments of diffusion image generation, the authors test ParaDiGMS on the settings of 1000 NFEs for DDPM, 200/500 NFEs for DDIM, and 200 NFEs for DPMSolver. It is questionable whether ParaDiGMS can achieve a similar speedup in fewer NFEs(like around 50 NFEs) since fewer NFEs are commonly used in downstream applications and the state-of-the-art samplers can achieve comparable results in this setting.

LIMITATIONS:
The author addressed the limitations of their work.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-07-08