Advanced sampling algorithms are designed to overcome the speed limitations of basic diffusion methods. Here, we implement and compare several popular samplers. The goal is to observe the trade-offs between generation speed (primarily influenced by the Number of Function Evaluations, or NFEs, which correlates with inference steps) and the resulting sample quality.
We will use a pre-trained diffusion model and compare the performance of the standard DDIM sampler against more advanced solvers like DPM-Solver++ and UniPC. This exercise will provide practical insight into choosing the right sampler for your specific needs.
First, ensure you have the necessary libraries installed. We'll primarily use the Hugging Face diffusers library for its convenient pipeline and scheduler implementations, along with PyTorch.
# pip install diffusers transformers accelerate torch
import torch
from diffusers import DiffusionPipeline, DDIMScheduler, DPMSolverMultistepScheduler, UniPCMultistepScheduler
import time
import matplotlib.pyplot as plt
from PIL import Image
import math
# Check for GPU availability
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")
# Load a pre-trained pipeline (e.g., Stable Diffusion or a smaller model)
# Using a smaller model like runwayml/stable-diffusion-v1-5 with reduced resolution
# or google/ddpm-cifar10-32 might be faster for experimentation.
# Here we use stable-diffusion-v1-5 as an example. Adjust based on your hardware.
model_id = "runwayml/stable-diffusion-v1-5"
pipeline = DiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16 if device == "cuda" else torch.float32)
pipeline = pipeline.to(device)
# Define a common prompt for comparison
prompt = "A photo of an astronaut riding a horse on the moon"
Make sure to log in to Hugging Face if necessary (huggingface-cli login) to download models like Stable Diffusion. Adjust the model_id and torch_dtype based on your available hardware and desired model. Using torch.float16 significantly speeds up generation on compatible GPUs.
The diffusers library makes it easy to switch schedulers (samplers). We'll instantiate the ones we want to compare: DDIM, DPM-Solver++, and UniPC.
# Instantiate the schedulers we want to compare
scheduler_ddim = DDIMScheduler.from_config(pipeline.scheduler.config)
scheduler_dpm = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config)
scheduler_unipc = UniPCMultistepScheduler.from_config(pipeline.scheduler.config)
# Store them for easy access
samplers = {
"DDIM": scheduler_ddim,
"DPM-Solver++": scheduler_dpm,
"UniPC": scheduler_unipc
}
Now, let's write a function to generate images using a given sampler and number of inference steps, measuring the time taken. We'll iterate through different step counts for each sampler.
def generate_and_time(pipe, sampler_name, sampler, prompt_text, num_steps, num_images=1):
"""Generates images using a specified sampler and times the process."""
pipe.scheduler = sampler # Set the pipeline's scheduler
start_time = time.time()
# Use a fixed generator for reproducibility if desired
generator = torch.Generator(device=device).manual_seed(42)
images = pipe(
prompt=prompt_text,
num_inference_steps=num_steps,
generator=generator,
num_images_per_prompt=num_images
).images
end_time = time.time()
generation_time = end_time - start_time
print(f"Sampler: {sampler_name}, Steps: {num_steps}, Time: {generation_time:.2f}s")
return images, generation_time
# Define the step counts to test
step_counts = [10, 20, 30, 50]
num_samples_per_setting = 1 # Generate 1 image per setting for quick visual comparison
results = {} # Store images and times
# Run generation for each sampler and step count
for name, sampler_instance in samplers.items():
results[name] = {"images": [], "times": [], "steps": []}
for steps in step_counts:
# Ensure model is compiled only once if using torch.compile (optional optimization)
# pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True) # Example
generated_images, gen_time = generate_and_time(
pipeline, name, sampler_instance, prompt, steps, num_samples_per_setting
)
results[name]["images"].extend(generated_images) # Store the first image
results[name]["times"].append(gen_time)
results[name]["steps"].append(steps)
Note: The optional torch.compile line can further accelerate generation on newer PyTorch versions and compatible hardware but might add overhead on the first run.
The most direct way to compare samplers, especially concerning artifacts or detail levels, is visual inspection. Let's arrange the generated images for easy comparison.
def plot_comparison_grid(results_dict, steps_list):
"""Plots a grid of generated images for comparison."""
num_samplers = len(results_dict)
num_steps_options = len(steps_list)
fig, axes = plt.subplots(num_samplers, num_steps_options, figsize=(num_steps_options * 3, num_samplers * 3.5))
fig.suptitle("Sampler Comparison: Quality vs. Steps", fontsize=16)
for i, (sampler_name, data) in enumerate(results_dict.items()):
for j, steps in enumerate(steps_list):
img_index = j # Since we generated 1 image per setting
if img_index < len(data["images"]):
ax = axes[i, j]
ax.imshow(data["images"][img_index])
ax.set_title(f"{sampler_name}\n{steps} Steps ({data['times'][j]:.1f}s)")
ax.axis('off')
else:
axes[i, j].axis('off') # Handle potential errors if generation failed
plt.tight_layout(rect=[0, 0.03, 1, 0.95]) # Adjust layout to prevent title overlap
plt.show()
plot_comparison_grid(results, step_counts)
Examine the output grid carefully:
You will likely observe that DPM-Solver++ and UniPC can generate reasonable images in fewer steps compared to DDIM. However, the optimal number of steps and the subtle differences in output style can vary between models and prompts.
We already recorded the generation time. Let's visualize the time taken versus the number of steps for each sampler.
Comparison of generation time for different samplers across varying numbers of inference steps. Note: Actual times depend heavily on hardware, model size, image resolution, and software optimizations. The data shown here is illustrative.
This chart typically shows that generation time scales roughly linearly with the number of steps for most samplers. While the advanced solvers might have slightly different computational overhead per step, their main advantage lies in achieving good quality with fewer steps, thus reducing the overall time. In this illustrative data, DPM-Solver++ and UniPC show slightly lower times for the same step count compared to DDIM, but their primary benefit comes from needing fewer steps (e.g., achieving good quality at 20 steps vs. DDIM needing maybe 30-50).
This practical demonstrates the clear benefits of using advanced sampling algorithms like DPM-Solver++ and UniPC.
By running these comparisons yourself, potentially with different models or prompts, you gain valuable intuition for selecting and configuring samplers effectively, balancing the demands of generation speed and output fidelity in your own projects. Remember also to consider optimizations covered later, such as quantization or model compilation, which work alongside the choice of sampler to further improve performance.
Was this section helpful?
© 2026 ApX Machine LearningEngineered with