Stable Diffusion Model Checkpoints Explained: Comparing v1-1, v1-2, v1-3, and v1-4

Use the v1-4 checkpoint for the highest visual fidelity and robustness, while earlier versions like v1-1 are suitable for limited GPU memory or faster inference scenarios.

The CompVis/stable-diffusion repository releases Stable Diffusion v1 as a series of four model checkpoints that share identical architecture but differ in training data quality, total optimization steps, and fine-tuning techniques. Understanding these differences helps you select the optimal checkpoint for your specific generation task.

Architecture Shared Across All Checkpoints

All Stable Diffusion model checkpoints use the same underlying latent diffusion architecture implemented in ldm/models/diffusion/ddim.py and configured via configs/stable-diffusion/v1-inference.yaml. The core components include:

• 860M parameter UNet for noise prediction in latent space
• Frozen CLIP ViT-L/14 text encoder for text conditioning
• 8× downsampling auto-encoder for efficient latent representation

Because the architecture remains constant, you can switch between checkpoints without modifying the inference configuration file.

Key Differences Between Stable Diffusion Checkpoints

The four checkpoints represent progressive improvements in training data filtering, total optimization steps, and regularization techniques.

Checkpoint	Training History	Dataset Used	Key Fine-Tuning Changes	Approx. Steps & Resolution
v1-1	First checkpoint	LAION-2B-en (256×256) + LAION-high-resolution (≥1024×1024)	Baseline model	237k steps at 256×256; additional 194k steps at 512×512
v1-2	Resumed from v1-1	LAION-aesthetics v2 5+ (filtered for aesthetics >5 and size ≥512×512)	Longer training on higher-quality subset	515k steps at 512×512
v1-3	Resumed from v1-2	Same aesthetics v2 5+ subset	10% text-conditioning dropout – improves classifier-free guidance sampling	195k steps at 512×512
v1-4	Resumed from v1-2 (same base as v1-3)	Same aesthetics v2 5+ subset	Same 10% dropout, but more training steps (225k at 512×512)	225k steps at 512×512

Critical technical distinctions:

• Dataset quality: v1-2 onward filters LAION for aesthetic scores above 5 and minimum resolution, removing noisy training samples that degrade output quality.
• Text-conditioning dropout: Introduced in v1-3 and retained in v1-4, this technique randomly drops the CLIP text embedding during training. According to the Stable_Diffusion_v1_Model_Card.md, this makes the model more robust to classifier-free guidance (CFG) scale values at inference time, enabling sharper results when using the --scale parameter in scripts/txt2img.py.
• Training duration: v1-4 receives the most optimization steps (225k) on the highest-quality data subset, yielding the best visual fidelity reported in the repository.

Which Stable Diffusion Checkpoint Should You Use?

Select your checkpoint based on hardware constraints and quality requirements:

Scenario	Recommended Checkpoint	Rationale
Best quality (default)	sd-v1-4.ckpt	Most training steps, text-dropout regularization, and highest-quality dataset yield superior detail and CFG stability.
Limited GPU memory / faster inference	sd-v1-1.ckpt	Smaller training budget results in slightly less sharp outputs but marginally lower memory footprint and faster loading.
Research / reproducibility	Any version	All use the same configs/stable-diffusion/v1-inference.yaml; simply point --ckpt to the desired file.
High guidance scale experiments	sd-v1-3.ckpt or sd-v1-4.ckpt	The 10% text-conditioning dropout specifically improves stability at high CFG scales (e.g., --scale 7.5 or higher).

In practice, the Hugging Face diffusers integration and most community tooling reference CompVis/stable-diffusion-v1-4 as the default because it provides the highest fidelity without requiring additional engineering.

How to Load and Use Different Checkpoints

All checkpoints load through the same utility functions in ldm/util.py and follow the inference configuration in configs/stable-diffusion/v1-inference.yaml.

Sampling with the Reference Script

Use scripts/txt2img.py to generate images with a specific checkpoint:

# Download the desired checkpoint (example: v1-4)

wget https://huggingface.co/CompVis/stable-diffusion-v1-4/resolve/main/sd-v1-4.ckpt -O models/ldm/stable-diffusion-v1/model.ckpt

# Run inference

python scripts/txt2img.py \
  --prompt "a cyberpunk city at sunset" \
  --ckpt models/ldm/stable-diffusion-v1/model.ckpt \
  --config configs/stable-diffusion/v1-inference.yaml \
  --plms \
  --scale 7.5 \
  --ddim_steps 50 \
  --n_samples 4

Argument details are documented in the script header and README.md.

Using the Hugging Face Diffusers Library

For rapid prototyping without manual checkpoint management:

from diffusers import StableDiffusionPipeline
from torch import autocast

# Load v1-4 (replace "v1-4" with "v1-2", etc., to switch versions)

pipe = StableDiffusionPipeline.from_pretrained(
    "CompVis/stable-diffusion-v1-4",
    torch_dtype="float16"
).to("cuda")

prompt = "an astronaut riding a horse on Mars"
with autocast("cuda"):
    image = pipe(prompt, guidance_scale=7.5).images[0]

image.save("astronaut.png")

The diffusers integration is described in the repository's README.md under the Diffusers Integration section.

Programmatic Checkpoint Selection

To expose checkpoint selection in your own tools:

import argparse
from scripts.txt2img import main as txt2img_main

parser = argparse.ArgumentParser()
parser.add_argument("--ckpt-version", choices=["v1-1","v1-2","v1-3","v1-4"], default="v1-4")
args = parser.parse_args()

ckpt_map = {
    "v1-1": "sd-v1-1.ckpt",
    "v1-2": "sd-v1-2.ckpt",
    "v1-3": "sd-v1-3.ckpt",
    "v1-4": "sd-v1-4.ckpt",
}
args.ckpt = f"models/ldm/stable-diffusion-v1/{ckpt_map[args.ckpt_version]}"
txt2img_main()

This pattern allows users to switch between Stable Diffusion model checkpoints without modifying the underlying inference logic in ldm/models/diffusion/ddim.py.

Summary

• All v1 checkpoints share the same architecture (860M UNet, CLIP ViT-L/14, 8× autoencoder) and load via configs/stable-diffusion/v1-inference.yaml.
• v1-1 provides the baseline with LAION-2B training at 256×256 and 512×512.
• v1-2 introduces aesthetic filtering (score >5) and longer training (515k steps).
• v1-3 adds 10% text-conditioning dropout to improve classifier-free guidance stability.
• v1-4 offers the highest quality with 225k steps on the aesthetic subset and the same dropout regularization as v1-3.
• Default recommendation: Use sd-v1-4.ckpt for production workloads, falling back to earlier checkpoints only when constrained by GPU memory or specific research requirements.

Frequently Asked Questions

What is the difference between Stable Diffusion v1-3 and v1-4?

Both checkpoints use the same 10% text-conditioning dropout technique introduced in v1-3 to improve classifier-free guidance sampling. However, v1-4 receives an additional 30,000 training steps (225k total vs. 195k) on the LAION-aesthetics v2 5+ dataset. According to the Stable_Diffusion_v1_Model_Card.md, these extra steps yield superior visual fidelity and make v1-4 the recommended default for most applications.

Can I use the same configuration file for all Stable Diffusion v1 checkpoints?

Yes. All four checkpoints (sd-v1-1.ckpt through sd-v1-4.ckpt) are compatible with the single inference configuration located at configs/stable-diffusion/v1-inference.yaml. The model architecture defined in ldm/models/diffusion/ddim.py and instantiated via ldm/util.py remains identical across versions; only the learned weights differ.

Why does v1-4 perform better with high guidance scales?

Versions 1-3 and 1-4 were trained with 10% text-conditioning dropout, meaning the CLIP text embedding is randomly replaced with a null token during training. This technique, detailed in the model card, specifically improves the model's response to classifier-free guidance (CFG). When you set --scale 7.5 or higher in scripts/txt2img.py, v1-4 maintains coherence and sharpness better than v1-1 or v1-2, which were trained without this regularization.

Is there a significant speed difference between the checkpoints?

No. All checkpoints have identical parameter counts (860M UNet) and inference latency. Any perceived speed differences stem from hardware caching or the complexity of the generated image, not the checkpoint version. If you require faster inference, consider using float16 precision via the diffusers library or the --precision full flag in the reference scripts, rather than switching to an earlier checkpoint.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}