FFHQ

FFHQ (Flickr-Faces-HQ) is a dataset of 70,000 photographs of human faces, each aligned and cropped to $1024 \times 1024$ pixels and stored as PNG. Tero Karras, Samuli Laine and Timo Aila of NVIDIA collected it from Flickr for “A Style-Based Generator Architecture for Generative Adversarial Networks”, the StyleGAN paper, posted on arXiv in December 2018 and presented at CVPR 2019. The data went online in February 2019: the official repository’s first commit is dated 4 February 2019. It has no labels. It serves as a training and test distribution for image generation: StyleGAN, StyleGAN2 and StyleGAN3 report their main results on it, as do several diffusion models and studies of generative metrics. Two features matter for anyone using it. The images come only from photographs under Creative Commons or public-domain terms, and the alignment procedure that produced every crop is published as code, which defines the dataset as much as the photographs do.

Purpose

The authors wanted a face dataset of higher quality and much wider variation than the existing high-resolution ones (§1). The high-resolution face benchmark they compared with was CelebA-HQ, a cleaned and super-resolved subset of CelebA’s celebrity photographs that the same group had built in 2018. According to Appendix A of the CVPR version, FFHQ varies far more than CelebA-HQ in age, ethnicity and image background, and covers accessories such as eyeglasses, sunglasses and hats much better. The paper gives no numbers for these comparisons, and neither does the repository’s README, which repeats them in general terms (as of October 2026).

FFHQ was designed as a benchmark for generative adversarial networks, as the README says. The StyleGAN paper itself reports its ablations on both CelebA-HQ and FFHQ (Table 1).

Dataset Size

All counts below are from the README at commit 4826aa6 (8 March 2022). The per-folder counts are unchanged since the first commit; the ZIP archives were added on 10 February 2019. The paper (Appendix A) gives only the 70,000 aligned images at $1024^2$.

Part	Files	Size	Contents
images1024x1024	70,000	89.1 GB	Aligned and cropped PNG images, $1024 \times 1024$
thumbnails128x128	70,000	1.95 GB	PNG thumbnails, $128 \times 128$
in-the-wild-images	70,000	955 GB	The original Flickr photographs, as PNG
tfrecords	9	273 GB	Multi-resolution TFRecords for the TensorFlow StyleGAN and StyleGAN2 code
ffhq-dataset-v2.json	1	255 MB	Per-image metadata
All, with ZIP archives of each folder	210,014	2.56 TB	Hosted on Google Drive

The README states that the authors made sure the aligned set contains no duplicate images, but that the in-the-wild folder can hold several copies of one photograph when more than one face was taken from it. The nine TFRecord files hold the dataset at every power-of-two resolution from $4^2$ to $1024^2$ (ffhq-r02 to ffhq-r10 in the download script).

Classes

FFHQ has no classes and no attribute labels. Each image carries only metadata (README, “Metadata”):

• About the Flickr photograph: its URL, title, author, the country where it was taken, its licence name and URL, the upload date and the crawl date.
• About each image file: path, size, MD5 checksums of the file and of its pixels, and image dimensions.
• Geometry: the 68 facial landmarks reported by dlib, in both the aligned and the in-the-wild image, the axis-aligned face rectangle and the oriented crop quadrilateral in the in-the-wild image.
• Split: “training” or “validation”.

The README’s pie chart summarizes three fields. Of the images, 49.8% are under CC BY 2.0, 41.7% under CC BY-NC 2.0, 6.4% under the Public Domain Mark, 1.6% under CC0 and 0.5% are U.S. Government Works. The country is unknown for 85.0%. The largest known countries are the United States (6.0%), the United Kingdom (1.6%), Canada (0.7%), Spain (0.6%) and Taiwan (0.5%), with 5.7% elsewhere. These describe where photographs were taken, not who is in them.

Annotation Types

FFHQ was built by a pipeline rather than annotated. The paper (Appendix A) and the README describe four steps:

1. Crawl. Images were crawled from Flickr, and only images under permissive licences were collected.
2. Align and crop. Faces were aligned and cropped automatically. The paper cites the face alignment method of Kazemi and Sullivan (2014); the README names the dlib library and thanks Kazemi and Sullivan for the face detection and alignment work that made the collection possible.
3. Automatic filters. Several unnamed automatic filters pruned the set.
4. Human filtering. Amazon Mechanical Turk workers removed the occasional statue, painting or photo of a photo.

As of October 2026 neither source names the search queries, the number of candidate photographs, the filters and their thresholds, or the instructions and agreement figures of the Mechanical Turk step. Only the alignment is documented exactly, because the download script reproduces it: with --align, download_ffhq.py recreates exact replicas of the aligned images from the in-the-wild images and the landmarks in the metadata, according to the README’s “Download script” section.

The alignment as the official script computes it

The function recreate_aligned_images() in download_ffhq.py (commit 4826aa6) uses 68 dlib landmarks. It reduces them to four points: the left and right eye centres $\mathbf{e}_l, \mathbf{e}_r$, each the mean of the six landmarks around that eye (points 36–41 and 42–47), and the two mouth corners $\mathbf{m}_l, \mathbf{m}_r$ (points 48 and 54). With image coordinates in pixels and $y$ pointing down, it forms the eye midpoint $\mathbf{e} = (\mathbf{e}_l + \mathbf{e}_r)/2$, the eye-to-eye vector $\mathbf{a} = \mathbf{e}_r - \mathbf{e}_l$ and the eye-to-mouth vector $\mathbf{b} = (\mathbf{m}_l + \mathbf{m}_r)/2 - \mathbf{e}$. With $\mathbf{v}^{\perp} = (-v_y, v_x)$ denoting a quarter turn, the crop is the square with centre $\mathbf{c}$ and half-axes $\mathbf{x}$ and $\mathbf{y}$:

$$\hat{\mathbf{x}} = \frac{\mathbf{a} - \mathbf{b}^{\perp}}{\lVert \mathbf{a} - \mathbf{b}^{\perp} \rVert}, \qquad s = \max\big(2\lVert \mathbf{a} \rVert,\; 1.8\lVert \mathbf{b} \rVert\big), \qquad \mathbf{x} = s\,\hat{\mathbf{x}}, \qquad \mathbf{y} = \mathbf{x}^{\perp}, \qquad \mathbf{c} = \mathbf{e} + 0.1\,\mathbf{b}.$$

The corners are $\mathbf{c} - \mathbf{x} - \mathbf{y}$, $\mathbf{c} - \mathbf{x} + \mathbf{y}$, $\mathbf{c} + \mathbf{x} + \mathbf{y}$ and $\mathbf{c} + \mathbf{x} - \mathbf{y}$, so the side is $2s$. Three choices are encoded here:

• Orientation. For an upright face, $-\mathbf{b}^{\perp}$ points along the eye line, so $\mathbf{a} - \mathbf{b}^{\perp}$ is the sum of two estimates of the horizontal direction: the eye line itself, and the normal to the eye–mouth axis. As a vector sum it weights each by its length.
• Scale. The side is four eye distances or 3.6 eye-to-mouth distances, whichever is larger. When the head turns, the eyes move closer together in the image while the eye-to-mouth distance changes less, so the second term keeps the crop face-sized.
• Centre. The crop centre sits one tenth of the way from the eyes to the mouth, which puts the eyes above the middle of the image.

The script then prepares the photograph and resamples it:

• Shrink. If the crop side is at least 4,096 pixels, it first shrinks the photograph by an integer factor with PIL’s antialiasing filter.
• Crop. It cuts out the square’s bounding box plus a border of 10% of the side.
• Pad. If the square extends beyond the photograph or comes within 4 pixels of its edge, it pads all four sides by reflection, each by at least 30% of the side. The padding, and a strip of the photograph next to it, is blurred with a Gaussian of standard deviation 2% of the side, and the padding is faded towards the median colour.
• Resample. It maps the square onto a $4096 \times 4096$ image with PIL’s bilinear quadrilateral transform, then reduces that to $1024 \times 1024$ with PIL’s antialiasing (Lanczos) filter.

Some FFHQ images therefore contain blurred, mirrored content that was never in the photograph; the help text of the script’s --no-padding option calls this blur-padding.

A second variant, added to the script on 27 September 2021, rebuilds the unaligned FFHQ (FFHQ-U) of the StyleGAN3 paper (Karras et al., 2021, Appendix B.1). The options are --no-rotation, which sets $\hat{\mathbf{x}} = (1, 0)$ and so keeps the natural tilt of camera and head; --random-shift 0.2, which shifts the centre by a normal offset with standard deviation 20% of the crop side; --retry-crops, which redraws the shift up to 1,000 times until the crop fits inside the photograph; and --no-padding. The scale is computed as before.

Example: the crop on synthetic faces

The script renders grey “photographs” containing one geometric face: an ellipse with two dark eyes, a nose and a mouth line. Each face has a random position, size (eye distance $d$ from 40 to 90 pixels) and roll of up to ±30°, and five landmarks are known exactly: the eye centres, the nose tip and the mouth corners. It computes the crop as recreate_aligned_images() does, with the eye centres given directly instead of as means of six dlib points. It resamples the square to $128 \times 128$ and reports where the landmarks fall in a $1024 \times 1024$ output. It also locates the left eye’s dark blob in the resampled image, as a check on the warp. It then compresses one face horizontally to 60%, as turning the head does. Finally, it perturbs the five landmarks of one face with Gaussian noise, a stand-in for landmark detector error, and measures how the crop moves over 20,000 draws for each of three seeds. It runs in about 5 seconds with NumPy 2.3.5 and SciPy 1.16.3.

import numpy as np
from scipy import ndimage

# Geometric face template in "face units" (eye distance = 1, y points down):
# left eye, right eye, nose tip, left and right mouth corners.
TEMPLATE = np.array([[-0.5, 0.0], [0.5, 0.0], [0.0, 0.5], [-0.4, 1.0], [0.4, 1.0]])

def render_photo(rng, H=480, W=640, yaw_squash=1.0):
    """A grey 'photo' with one geometric face at a random position, size and roll.
    yaw_squash < 1 compresses the face horizontally, as turning the head does."""
    roll = np.deg2rad(rng.uniform(-30, 30))
    d = rng.uniform(40, 90)                                   # eye distance in pixels
    centre = np.array([rng.uniform(0.35, 0.65) * W, rng.uniform(0.3, 0.5) * H])
    R = np.array([[np.cos(roll), -np.sin(roll)], [np.sin(roll), np.cos(roll)]])
    S = np.diag([yaw_squash, 1.0])
    to_img = lambda q: centre + d * (q @ (R @ S).T)
    yy, xx = np.mgrid[:H, :W].astype(float)
    q = (np.stack([xx, yy], -1) - centre) @ R / d             # pixel -> face units
    q[..., 0] /= yaw_squash
    img = np.full((H, W), 0.3) + 0.1 * (xx / W)               # background with a gradient
    img[(q[..., 0] / 1.0) ** 2 + ((q[..., 1] - 0.45) / 1.35) ** 2 <= 1] = 0.8   # head
    for ex in (-0.5, 0.5):                                    # eyes
        img[(q[..., 0] - ex) ** 2 + q[..., 1] ** 2 <= 0.12 ** 2] = 0.05
    img[(np.abs(q[..., 0]) <= 0.4) & (np.abs(q[..., 1] - 1.0) <= 0.06)] = 0.15   # mouth
    img[(np.abs(q[..., 0]) <= 0.06) & (q[..., 1] > 0.2) & (q[..., 1] < 0.5)] = 0.6  # nose
    return img, to_img(TEMPLATE), np.rad2deg(roll), d

def ffhq_quad(lm, rotate=True):
    """Oriented crop rectangle as in recreate_aligned_images() of download_ffhq.py
    (eye centres and mouth corners here are given directly instead of as means of
    dlib's 68 points). Returns the corners UL, LL, LR, UR."""
    eye_l, eye_r, _nose, mouth_l, mouth_r = lm
    eye_avg = (eye_l + eye_r) * 0.5
    eye_to_eye = eye_r - eye_l
    mouth_avg = (mouth_l + mouth_r) * 0.5
    eye_to_mouth = mouth_avg - eye_avg
    if rotate:
        x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]   # mean of eye line and the
        x = x / np.hypot(*x)                                  # normal to the eye-mouth axis
    else:
        x = np.array([1.0, 0.0])                              # "unaligned FFHQ": no rotation
    x = x * max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)
    y = np.flipud(x) * [-1, 1]
    c = eye_avg + eye_to_mouth * 0.1
    return np.stack([c - x - y, c - x + y, c + x + y, c + x - y])

def warp(img, quad, size):
    """Resample the quad to a size x size image (bilinear), like PIL's QUAD transform."""
    u = (np.arange(size) + 0.5) / size
    U, V = np.meshgrid(u, u)
    q0, q1, q2, q3 = quad
    P = (q0 + U[..., None] * (q3 - q0) + V[..., None] * (q1 - q0)
         + (U * V)[..., None] * (q2 - q1 - q3 + q0))
    return ndimage.map_coordinates(img, [P[..., 1], P[..., 0]], order=1, mode="nearest")

def to_output(points, quad, size=1024):
    """Where image points land in the aligned output (the quad is a square)."""
    q0, q1, _, q3 = quad
    A = np.column_stack([q3 - q0, q1 - q0])
    return np.linalg.solve(A, (points - q0).T).T * size

rng = np.random.default_rng(0)
print("five photos: roll, eye distance -> landmarks in the 1024x1024 output, crop side")
for i in range(5):
    img, lm, roll, d = render_photo(rng)
    quad = ffhq_quad(lm)
    out = to_output(lm, quad)
    face = warp(img, quad, 128)
    ys, xs = np.nonzero(face[:, :64] < 0.1)                   # left eye blob in the 128 px crop
    print(f"roll {roll:6.1f} deg, d {d:5.1f} px | eyes ({out[0,0]:.1f}, {out[0,1]:.1f}) "
          f"({out[1,0]:.1f}, {out[1,1]:.1f}), mouth y {out[3,1]:.1f} | side {np.hypot(*(quad[3]-quad[0])) / d:.2f} d"
          f" | eye blob at ({8 * (xs.mean() + 0.5):.0f}, {8 * (ys.mean() + 0.5):.0f})")

img, lm, roll, d = render_photo(np.random.default_rng(1), yaw_squash=0.6)
quad = ffhq_quad(lm)
out = to_output(lm, quad)
print(f"\nhead turned (eye distance x0.6): side {np.hypot(*(quad[3]-quad[0])) / d:.2f} d, "
      f"eyes at x = {out[0,0]:.1f}, {out[1,0]:.1f}, mouth y {out[3,1]:.1f}")

print("\nlandmark noise (std, fraction of eye distance) -> spread of the crop over 20,000 draws")
print(" sigma  seed  rotation(deg)  side(%)  centre(% of side)  left eye in 1024 output (px)")
img, lm, roll, d = render_photo(np.random.default_rng(2))
true_quad = ffhq_quad(lm)
true_eye = to_output(lm[:1], true_quad)[0]
for sigma in (0.01, 0.03, 0.05):
    for seed in range(3):
        r = np.random.default_rng(100 + seed)
        rot, side, cen, eye = [], [], [], []
        for _ in range(20000):
            q = ffhq_quad(lm + r.normal(0, sigma * d, lm.shape))
            ex, tx = q[3] - q[0], true_quad[3] - true_quad[0]
            rot.append(np.rad2deg(np.arctan2(ex[1], ex[0]) - np.arctan2(tx[1], tx[0])))
            side.append(np.hypot(*ex) / np.hypot(*tx) - 1)
            cen.append(np.hypot(*(q.mean(0) - true_quad.mean(0))) / np.hypot(*tx))
            eye.append(np.hypot(*(to_output(lm[:1], q)[0] - true_eye)))
        print(f" {sigma:5.2f}  {seed:4d}  {np.std(rot):13.2f}  {100*np.std(side):7.2f}"
              f"  {100*np.sqrt(np.mean(np.square(cen))):17.2f}  {np.sqrt(np.mean(np.square(eye))):12.1f}")

five photos: roll, eye distance -> landmarks in the 1024x1024 output, crop side
roll    8.2 deg, d  53.5 px | eyes (384.0, 486.4) (640.0, 486.4), mouth y 742.4 | side 4.00 d | eye blob at (385, 487)
roll   18.8 deg, d  85.6 px | eyes (384.0, 486.4) (640.0, 486.4), mouth y 742.4 | side 4.00 d | eye blob at (384, 486)
roll    2.6 deg, d  86.8 px | eyes (384.0, 486.4) (640.0, 486.4), mouth y 742.4 | side 4.00 d | eye blob at (385, 484)
roll   21.4 deg, d  41.7 px | eyes (384.0, 486.4) (640.0, 486.4), mouth y 742.4 | side 4.00 d | eye blob at (383, 486)
roll   21.8 deg, d  67.1 px | eyes (384.0, 486.4) (640.0, 486.4), mouth y 742.4 | side 4.00 d | eye blob at (383, 485)

head turned (eye distance x0.6): side 3.60 d, eyes at x = 426.7, 597.3, mouth y 768.0

landmark noise (std, fraction of eye distance) -> spread of the crop over 20,000 draws
 sigma  seed  rotation(deg)  side(%)  centre(% of side)  left eye in 1024 output (px)
  0.01     0           0.50     1.41               0.23           3.2
  0.01     1           0.49     1.43               0.23           3.2
  0.01     2           0.49     1.42               0.23           3.2
  0.03     0           1.49     4.13               0.68           9.6
  0.03     1           1.48     4.19               0.68           9.6
  0.03     2           1.48     4.18               0.68           9.6
  0.05     0           2.48     6.42               1.14          15.6
  0.05     1           2.47     6.48               1.13          15.5
  0.05     2           2.47     6.48               1.13          15.6

Whatever the roll, size and position of the face, the crop sends the eyes to the same pixels: one eighth of the output width either side of the centre, and 0.1/4 of the width above it, because the side is $4d$ and the centre lies $0.1\,d$ below the eyes for this face, whose mouth is one eye distance below the eyes. The dark blobs found in the resampled images sit within a few pixels of the predicted positions, at the 8-pixel granularity of the $128^2$ warp. This canonical placement is what “aligned” means in FFHQ: the eyes and mouth of every face land in nearly the same place, which by our reading spares a generator from having to model where the face is. For the turned head, the eye-to-mouth term takes over ($3.6d$ instead of $4d$). The face is framed by its height, the eyes land closer together and the mouth lower, so a turned face in FFHQ is framed differently from a frontal one.

Landmark noise moves the crop in proportion to its size, and the three seeds agree to within 0.06 percentage points on the side and 0.01° on the rotation. Every spread grows linearly with the noise, so even a detector error of a few percent of the eye distance shifts the eyes by several output pixels. The scale is the most sensitive quantity: it is set by $\lVert \mathbf{a} \rVert$, the difference of two noisy points, so its relative error is about $\sqrt{2}\,\sigma$ when $\sigma$ is expressed as a fraction of the eye distance. By our reasoning, averaging six dlib points per eye in the real script reduces this if their errors are independent, which a detector’s errors on neighbouring points need not be; we found no published failure rate of the dlib landmarks on FFHQ.

We cross-checked this reimplementation against the official function by running a verbatim copy of recreate_aligned_images() from commit 4826aa6 on five synthetic photographs. Each was saved as an RGB PNG with 68 landmarks built so that the eye means and mouth corners equal the five synthetic points, and the five cases included one with rotate_level=False and one that triggered the reflection padding. The only change needed (with Pillow 12.0.0) was an alias for the PIL.Image.ANTIALIAS constant, which Pillow 10 removed and which named the Lanczos filter. Its crop quadrilaterals, recorded from the arguments it passes to PIL and mapped back to photograph coordinates, matched ours to within $5 \times 10^{-13}$ pixels in all five cases. The left eye in its $1024^2$ outputs was found within 0.7 pixels of the position predicted above.

Splits

For uses that need separate training and validation sets, the README appoints the first 60,000 images (indices 0 to 59,999) for training and the remaining 10,000 for validation. It adds that the StyleGAN paper trained on all 70,000. The generative benchmark follows the paper: StyleGAN2’s Table 1 caption gives FFHQ as 70,000 images (Karras et al., 2020, arXiv v2), and the later NVIDIA papers use all of them as the FID reference (see Evaluation).

One public codebase splits differently. The FFHQ configuration of latent diffusion (ffhq-ldm-vq-4.yaml) loads its data through the taming-transformers lists ffhqtrain.txt (60,000 file names) and ffhqvalidation.txt (10,000). These lists are not the README’s split: 8,603 of the 10,000 validation files have indices below 60,000.

Tasks

• Unconditional image generation, the purpose FFHQ was built for, at $1024^2$ and at downsampled resolutions.
• Latent-space editing and GAN inversion, which project real FFHQ faces into a generator trained on FFHQ (StyleGAN covers the methods).
• Generative modelling with limited data: subsets of 1,000 to 30,000 FFHQ images test training methods for small datasets (Karras et al., 2020, ADA paper).
• Pretraining for transfer: the ADA paper fine-tuned generators trained on FFHQ-140k on MetFaces and other small datasets (Figure 11a).
• 3D-aware generation from single-view photographs (neural rendering describes EG3D, trained on FFHQ).
• Research on generative metrics, including the dependence of FID on ImageNet classes, which the Fréchet Inception Distance article covers.

Development or improvement of facial recognition is excluded by the README (see License).

Evaluation

FFHQ has no official test set, evaluation server or leaderboard. Its protocol comes from NVIDIA’s StyleGAN papers and code: FID between generated images and FFHQ images, computed with an Inception-v3 network and the FID formula (that article covers both). What differs between papers is which images enter each side.

FID as the official StyleGAN code computes it

• StyleGAN (2019) and StyleGAN2 (2020), TensorFlow. The metric fid50k uses num_images=50000 for both sides (metric_base.py in the StyleGAN repository; metric_defaults.py in StyleGAN2’s). The real statistics come from the first 50,000 images the dataset loader delivers, with shuffling disabled (shuffle_mb = 0). They are flipped left–right at random, each with probability 0.5, when the evaluated run trained with mirror augmentation (misc.apply_mirror_augment), as StyleGAN did on FFHQ (supplementary material, §1). Which 50,000 of the 70,000 these are depends on the order of the TFRecord files. The repository’s dataset_tool.py shuffles that order with a fixed seed by default, and the paper describes the images as drawn randomly from the training set (Table 1 caption); we did not download the distributed files to check their order. The paper reports the lowest FID encountered over training. StyleGAN2 selects the snapshot with the lowest FID and averages each metric over 10 evaluations with different random seeds (Table 1 caption, arXiv v2).
• ADA (2020), StyleGAN3 (2021) and their PyTorch code. The recommended metric fid50k_full in metric_main.py (StyleGAN3, commit c233a91) sets max_real=None and xflip=False. The real statistics therefore cover all 70,000 images without flips, against 50,000 generated images. The papers state the same protocol (ADA §2; StyleGAN3 Figures 3 and 12). The legacy fid50k there uses max_real=50000. The dataset class shuffles only when a maximum size is set before flipping, and max_size stays None, so by our reading of training/dataset.py and dataset_tool.py the real side is then the first 50,000 images in file-name order.
• Precision and recall. Kynkäänniemi et al. (2019) set $k = 3$ nearest neighbours and 50,000 real and generated images in VGG-16 features as their default (§2), choosing 50,000 to match FID practice. StyleGAN3’s pr50k3_full uses up to 200,000 real images, which for FFHQ means all 70,000, with 50,000 generated. StyleGAN2 reports these numbers in Table 1. The FID article describes the metric.

Conventions that change the number

Each line below changes FID on “FFHQ” without any change to the generator. Results are comparable only when all of them match.

Convention	Variants in use	Sources
Real statistics	50,000 images (with random flips if trained with mirroring) or all 70,000 without flips	StyleGAN/StyleGAN2 fid50k; StyleGAN3 fid50k_full
Training set	70,000; 70,000 plus horizontal flips (“140k”); subsets of 1,000 to 30,000; a 60,000-image list	ADA Figure 7; latent diffusion configuration
Resolution	$1024^2$, $256^2$, $64^2$	StyleGAN family; ADA and latent diffusion; EDM
Downsampling	$2 \times 2$ box averaging per level; PIL Lanczos; OpenCV bilinear	StyleGAN dataset_tool.py; StyleGAN3 and EDM dataset_tool.py; taming-transformers loader
Alignment	aligned FFHQ or FFHQ-U	StyleGAN3 Figure 5
Reported value	lowest over training; mean of 10 evaluations of the best snapshot; minimum of 3 evaluations; median of 3 training runs	StyleGAN; StyleGAN2; EDM; ADA

Reference set. Using all 70,000 real images rather than 50,000 changes the real statistics. With small training subsets it also decides what FID measures: ADA scores every subset against all 70,000 images, whichever subset was trained on (§2). Its authors estimated the bias that remains by scoring a hypothetical generator that copies its training subset. The bias was negligible with 20,000 or more training images and dominated with 2,000 or fewer (Appendix A, arXiv v2). FID’s small-sample bias in general is covered in the FID article.

Flips. Training on the 70,000 images plus their mirror images, which ADA calls FFHQ-140k, is a different training distribution. Its baseline StyleGAN2 reached a median FID of 3.71, against 5.28 on the 70,000 alone (Figure 7c, $256^2$, three runs each).

Resolution and downsampling. Each resolution is its own benchmark. The downsampled images are not uniquely defined either:

• The TFRecords contain each level made by averaging $2 \times 2$ blocks of the level above (add_image in StyleGAN’s dataset_tool.py).
• The PyTorch dataset_tool.py of StyleGAN3, and EDM’s, resize with PIL’s Lanczos filter. EDM’s README builds its $64^2$ FFHQ this way from images1024x1024.
• The latent diffusion FFHQ configuration loads the 1024-pixel images through taming-transformers, which resizes them with Albumentations’ SmallestMaxSize. In version 0.4.3, pinned by both repositories’ environment files, its interpolation defaults to OpenCV’s bilinear filter.

The paper itself does not state its resizing (Rombach et al., 2022, Appendix E.3.1, arXiv v2). Parmar et al. (2022, Table 3, arXiv v3) measured what this choice does. They downsampled FFHQ from 1024 to 256 pixels in four ways, trained StyleGAN2 (config E) three times on each, and scored all with the same antialiased FID resizing. The FIDs, computed over the three runs, were 4.82 for nearest-neighbour subsampling, 5.08 for TensorFlow bilinear, 5.13 for PyTorch bilinear and 6.21 for PIL bicubic. The antialiased version scored worst; the authors hypothesize that because it keeps more of the original information, it is harder to model. The resizing inside FID, from the stored resolution to $299^2$, is a separate effect that the FID article covers.

Alignment. FFHQ-U is a different dataset. At $1024^2$, StyleGAN3’s StyleGAN2 baseline (its config B, StyleGAN2 with Fourier features) scored 2.70 on FFHQ and 3.79 on FFHQ-U (Figure 5, arXiv v4).

Run-to-run variation. Kynkäänniemi et al. (2019, §4.1) observed that with StyleGAN, FID often varies by up to ±14% between consecutive training iterations. EDM’s authors put the random variation of a single FID evaluation at typically ±2% and report the minimum of three (Appendix F.1, arXiv v2). We infer, without a source measuring it on FFHQ, that selecting the lowest of several noisy evaluations lowers the reported value, so “lowest over training” and “minimum of three” are not interchangeable with a single evaluation.

Diffusion papers inherit these choices. Latent diffusion computes FID with the torch-fidelity package from 50,000 samples against the entire training set of each dataset (Appendix E.3.1, arXiv v2). It does not say whether, for FFHQ, that means the 60,000 images its configuration trains on or all 70,000. Its FFHQ table takes the comparison methods’ results from earlier papers rather than recomputing them (Table 1 caption). EDM’s reference set, all available real images, comes without flips and is scored with the Inception-v3 weights of StyleGAN3 (Appendix F.1).

License

As of October 2026 (README and LICENSE.txt at commit 4826aa6, unchanged since 8 March 2022), the repository distinguishes two layers:

• The photographs. Each was published on Flickr by its author under one of five terms:

  • Creative Commons BY 2.0;
  • Creative Commons BY-NC 2.0;
  • Public Domain Mark 1.0;
  • Public Domain CC0 1.0;
  • U.S. Government Works.

  According to the README, all five allow free use, redistribution and adaptation for non-commercial purposes, and some require credit to the original author and an indication of changes. The licence and author of each image are recorded in the metadata.

• The dataset. NVIDIA Corporation makes the dataset itself, which the README says includes the JSON metadata, the download script and the documentation, available under Creative Commons BY-NC-SA 4.0. Users must cite the paper, indicate changes and share derivative works under the same licence. The StyleGAN3 paper (Appendix B.4) and EDM (Appendix F.5) restate this licence.

A LICENSE.txt with the same text accompanies each download folder. The README directs business inquiries to NVIDIA’s research licensing form; until November 2021 it gave an email address instead. Since 8 March 2022 its introduction has also said that the dataset is not intended for, and should not be used for, developing or improving facial recognition technologies.

Several points are unclear in the terms as written:

• Which licence governs the aligned images. The README’s parenthesis names the JSON metadata, script and documentation but does not say outright whether the aligned crops, which are adaptations of the photographs, fall under NVIDIA’s licence, the photographers’ licences, or both.
• The facial recognition sentence. It stands in the README’s introduction, not in its Licenses section or in LICENSE.txt, so its legal force is not stated.
• Trained models. The README does not say whether a generator trained on FFHQ is a derivative work subject to share-alike.

About half of the photographs are under CC BY 2.0, which by its terms permits commercial use, so read alone they would allow more than the dataset licence. We give no legal reading of how the two layers combine; the README’s summary is that the whole is for non-commercial use.

Limitations and Bias

• Flickr’s population. The paper and the README say that FFHQ inherits all the biases of Flickr, without quantifying them. The country field cannot do so either: it is unknown for 85% of images and refers to where the photograph was taken.
• Demographic composition. The only peer-reviewed audit we found is by Maluleke et al. (2022, read in arXiv v2, §3.3 and §4.1). Amazon Mechanical Turk workers labelled the perceived race of a random sample of 1,000 FFHQ images, choosing among Black, white, non-Black or non-white, and cannot determine. The authors condensed FairFace’s seven race categories to these to reduce perceptual ambiguity; on 1,000 FairFace validation images, their annotations agreed with FairFace’s labels 76% of the time (Figure 2). They report FFHQ as 69% white, 4% Black and 27% non-Black or non-white, and call it under-representative compared with the global Black population. Without truncation, a StyleGAN2-ADA trained on FFHQ preserved the proportion of Black to white labels (§4.1, Figure 3). At truncation 0.5, the share of generated images labelled Black fell from 4% to 0% (§4.1, Figure 4). The audit concerns perceived race only, in three categories, on one sample. Neither the paper nor the README gives figures for age or gender, which the paper’s diversity claim also invokes. Dataset bias discusses such audits across datasets.
• Consent. The licences were granted by the Flickr accounts that uploaded the photographs. The README’s Privacy section says the authors were careful to include only photos that, to the best of their knowledge, their authors intended for free use and redistribution. As of October 2026, neither the paper nor the README says whether the people pictured were asked or informed.
• Opt-out. The Privacy section was added on 19 March 2019, six weeks after the first commit, together with a search tool that finds a user’s photos by Flickr username. To have a photo removed, its owner marks it on Flickr in one of four ways: tagging it no_cv, changing its licence to all rights reserved or a NoDerivs licence, making it private, or deleting it. The owner then emails NVIDIA with their Flickr username, and NVIDIA checks all of that user’s photos and updates the dataset accordingly. The process is keyed to the uploader’s account; the README describes no separate route for a person who appears in someone else’s photograph.
• Removal history. As of October 2026 the README records no removals, and its count of 70,000 images per folder has not changed since the first commit. In June 2019 the metadata file was renamed from ffhq-dataset-v1.json to ffhq-dataset-v2.json when the files were reorganized into subfolders of 1,000. By our arithmetic, its size grew by 1,260,000 bytes, exactly 18 bytes for each of the 70,000 records, which matches the three longer file paths per record. This suggests no records were removed in that change, though without the files we cannot confirm it.
• Processing artefacts. The crop is fixed relative to the eyes and mouth, so faces share a nearly fixed position, scale and in-plane rotation. The StyleGAN3 authors built FFHQ-U to retain the natural variation of camera and head tilt (Appendix B.1). Reflection padding puts blurred, mirrored content into images whose faces were near the photograph’s edge. Any landmark error moves the crop, as the example shows.
• Human filtering is narrow. The only manual step removed statues, paintings and photos of photos. The sources mention no review of image content beyond that.

Common Uses

• The headline benchmark of the StyleGAN line. StyleGAN, StyleGAN2 and StyleGAN3 each report FFHQ at $1024^2$ as their main result. The StyleGAN article tabulates them with their protocols.
• Diffusion models at lower resolution. Latent diffusion reports FFHQ at $256^2$ (the paper’s results), and EDM studies training design for diffusion models on FFHQ at $64^2$ alongside CIFAR-10 and AFHQv2.
• Data efficiency. With LSUN Cat, FFHQ was one of the two datasets whose subsets were used to develop adaptive discriminator augmentation.
• Metric research. The improved precision and recall metric was demonstrated on StyleGAN trained on FFHQ, alongside BigGAN on ImageNet (Kynkäänniemi et al., 2019), and FID’s sensitivity to resizing and compression was measured partly on it (Parmar et al., 2022).

Historical Milestones

FIDs as printed, lower is better; each row’s protocol is given, and rows with different protocols are not comparable.

Year	Result	Protocol	Source
2019	FFHQ released; StyleGAN 4.40 against 8.04 for the Progressive GAN baseline	$1024^2$, all 70,000 for training, 50,000 images, lowest over training	Karras et al., 2019, Table 1
2019	Improved precision and recall introduced; StyleGAN with truncation trades recall for precision	$1024^2$, $k = 3$, 50,000 images, VGG-16 features	Kynkäänniemi et al., 2019, §2–§3, Figure 5
2020	StyleGAN2 2.84, with precision 0.689 and recall 0.492	$1024^2$, lowest-FID snapshot, mean of 10 evaluations	Karras et al., 2020, Table 1, arXiv v2
2020	ADA with 1,000 training images: 21.29 against 100.16 for the baseline	$256^2$, median of 3 runs, all 70,000 images as reference	Karras et al., 2020, Figure 7c, arXiv v2
2021	StyleGAN3-T 2.79, StyleGAN3-R 3.07 (StyleGAN2 baseline with Fourier features 2.70); FFHQ-U introduced	$1024^2$, 50,000 generated against all training images	Karras et al., 2021, Figure 5, arXiv v4
2022	Latent diffusion LDM-4: 4.98, precision 0.73, recall 0.50	$256^2$, 200 DDIM steps, 50,000 samples against the training set	Rombach et al., 2022, Table 1
2022	EDM: 2.39 (VP) and 2.53 (VE), from 3.39 and 25.95 with Song et al.’s original training setup	$64^2$, 79 network evaluations, minimum of 3 FID evaluations	Karras et al., 2022, Table 2, arXiv v2
2022	Downsampling alone moves StyleGAN2’s FID from 4.82 to 6.21	$256^2$, four resizing methods, 3 runs each	Parmar et al., 2022, Table 3, arXiv v3

Related Datasets

• CelebA-HQ. The 30,000-image high-resolution derivative of CelebA, built by the same group in 2018 with a similar oriented crop. FFHQ was introduced as its more varied replacement; the CelebA article describes how it was made.
• FFHQ-U. The unaligned rebuild of FFHQ from the StyleGAN3 paper, produced by the official script’s options described above.
• MetFaces. 1,336 faces extracted from the Metropolitan Museum of Art’s collection, released with ADA; after automated and manual filtering they were cropped and aligned at $1024^2$ (ADA, §4.3 and Appendix D.3). Its images are under CC0 from the museum, and NVIDIA distributes the dataset under CC BY-NC 2.0 (StyleGAN3, Appendix B.4).
• AFHQ. Animal faces (cats, dogs and wildlife) released with StarGAN v2 by NAVER (StyleGAN3, Appendix B.4), a companion benchmark: StyleGAN3 trains on a resampled version, AFHQv2, of 15,803 images at $512^2$ (Figure 5), and EDM on AFHQv2 at $64^2$.
• LSUN. Scene and object categories, such as bedrooms and churches, that StyleGAN-family papers report alongside FFHQ as non-face benchmarks.
• Face recognition datasets such as Labeled Faces in the Wild carry identity labels, which FFHQ does not, and serve a use its README excludes.

Resources

• Official repository: README with the licences, the metadata format and the privacy procedure; download_ffhq.py, which downloads the data, verifies checksums and recreates the aligned images (--align) and FFHQ-U.
• Search tool, linked from the README, for finding photos by Flickr username.
• Official StyleGAN code with the metric implementations: StyleGAN, StyleGAN2, StyleGAN3 (fid50k_full, pr50k3_full).
• EDM repository, with the commands that build the $64^2$ FFHQ and its FID reference statistics.
• There is no official leaderboard or evaluation server; results are self-reported under the conventions above.