vdanilov/video-bokeh

Video Bokeh

The data of the video-bokeh project, for training depth-aware bokeh on video. This repository holds its library under library/: 8,586 foregrounds, which are cut-out objects, and 20,000 background photos, each with a disparity map. The project's code works in two stages. Stage A built this library once, from MAGICK and BG-20k images and Depth Anything V2 Large. Stage B composes training sequences from it, moving the foregrounds over a background at disparities it assigns, so the mattes, disparity and bokeh of every frame match the frame by construction.

Foregrounds and backgrounds of the library. A foreground's color is drawn over a checkerboard and its disparity inside the matte, gray where the matte is under 0.04. Disparity is drawn in the Spectral colormap, near red and far violet.

Sequences that Stage B generated from this library at 1024 × 1024. Top: the frames all in focus, their disparity and each object's matte in its own color. Bottom: their bokeh, the forward optical flow, colored by direction and speed, and in cyan what the next frame hides.

At a glance

	foregrounds	backgrounds
items	8,586	20,000
image size	1024 × 1024	1536 × 1536
files per item	rgb.png, alpha.png, depth.png, meta.json	rgb.png, depth.png
tar shards	11	48
size	20.5 GB	94.4 GB

• 59 shards, 114.9 GB in all. The largest shard is 2.0 GB.
• depth.png holds disparity. Larger values are closer.
• One estimator. Every map comes from Depth Anything V2 Large.

Quick start

fetch downloads the shards one at a time and unpacks each into a library folder, so the disk needs 114.9 GB for the library plus room for one shard. A second run downloads only the shards the first did not unpack. It needs Python 3.13 and uv.

git clone https://github.com/ViacheslavDanilov/video-bokeh
cd video-bokeh/backend
uv sync --no-dev --extra loader
uv run python -m video_bokeh.library.hub fetch --repo vdanilov/video-bokeh --output data/library/da2-large

The folder it writes is the layout Stage B reads:

data/library/da2-large/
├── foregrounds/<id>/rgb.png, alpha.png, depth.png, meta.json
└── backgrounds/<id>/rgb.png, depth.png

SequenceStream, the project's PyTorch dataset, runs Stage B on that folder in memory. Each item is a new sequence, generated on the fly and never written to disk:

from pathlib import Path

from video_bokeh.loader import SequenceStream

stream = SequenceStream(
    Path("data/library/da2-large"),
    n_frames=8,
    size=256,
    streams=("rgb", "disparity", "bokeh"),
)
item = next(iter(stream))
print(item["rgb"].shape, item["disparity"].shape, item["bokeh"].shape)
# torch.Size([8, 3, 256, 256]) torch.Size([8, 1, 256, 256]) torch.Size([8, 3, 256, 256])

uv run python -m video_bokeh.loader.example --library-root data/library/da2-large trains a small network on it for 20 steps. The project's README shows how to write sequences to disk instead, with optical flow and the layers each frame is composited from.

To read one item without the code, open its files with Pillow and NumPy:

import numpy as np
from PIL import Image

item = "data/library/da2-large/foregrounds/<id>"
rgba = np.asarray(Image.open(f"{item}/rgb.png"))  # (H, W, 4) uint8
matte = np.asarray(Image.open(f"{item}/alpha.png")) / 255.0  # (H, W) in [0, 1]
disparity = np.asarray(Image.open(f"{item}/depth.png")) / 65535.0  # (H, W) in [0, 1]

The datasets library, with Pillow, streams the shards without the code and without the download, one sample per item:

from datasets import load_dataset

foregrounds = load_dataset("vdanilov/video-bokeh", "foregrounds", split="train", streaming=True)
item = next(iter(foregrounds))
# keys: rgb.png, alpha.png, depth.png, depth_preview.jpg, json, __key__ (the id), __url__

Repository layout

README.md
assets/preview.jpg
assets/preview.mp4
library/index.json
library/foregrounds/foregrounds-00000.tar … foregrounds-00010.tar
library/backgrounds/backgrounds-00000.tar … backgrounds-00047.tar

• A shard is a plain tar. The images are PNG already, so it is not compressed again.
• A shard holds whole items, in WebDataset's layout. An item's files share its id, as <id>.rgb.png, <id>.alpha.png, <id>.depth.png and <id>.json. fetch writes them back as foregrounds/<id>/rgb.png and so on, the layout Stage B reads, shown under Quick start.
• Each item also holds <id>.depth_preview.jpg, its disparity in color at the item's size, drawn for a foreground where its matte reaches 0.04. It is there for the viewer, and fetch leaves it out.
• library/index.json lists the shards of each kind, with the number of items and the bytes each holds. fetch reads it first.
• The viewer has a subset per kind, foregrounds and backgrounds, with a row per item and a column per file.

What each file holds

file	mode	type	values
foregrounds/<id>/rgb.png	RGBA	uint8	the cut-out, with its matte as alpha
foregrounds/<id>/alpha.png	L	uint8	the matte, 0 transparent to 255 opaque
foregrounds/<id>/depth.png	I;16	uint16	disparity over the whole square, 0 far to 65535 near
foregrounds/<id>/meta.json	JSON		how the item was made
backgrounds/<id>/rgb.png	RGB	uint8	the photo
backgrounds/<id>/depth.png	I;16	uint16	disparity, 0 far to 65535 near

• Each disparity map is scaled to its own range. Its smallest value is stored as 0 and its largest as 65535. Values cannot be compared across items, and no map holds metric depth. Stage B stretches every map into the band of disparity it assigns, so only the shape inside a map matters.
• A foreground's disparity covers the whole square. Inside the trusted core (step 4 below) it is the estimator's. Everywhere else, including the matte's edge and the holes the cleanup dropped, it is copied from the nearest core pixel and blurred. Stage B reads it wherever the matte is above 0. The preview draws it where the matte reaches 0.04, the threshold of the core, and leaves the faint halo below it gray.
• Ids name the source image. A foreground id is MAGICK's image path without its extension, with __ for the slash. A background id is BG-20k's split and file name the same way, train__h_… or testval__h_….
• meta.json records the estimator, the source image, the cleanup settings below and statistics of the raw estimate, such as core_frac, the share of the square the trusted core covers, and low_confidence, true when that core is under 0.2 % of it.

How it was built

1. Foregrounds. We started from the 11,868 MAGICK images its authors picked by hand. A zero-shot classifier, Perception Encoder (PE-Core-bigG-14-448, run through OpenCLIP), labeled each with a subject and a style. We kept the subjects person, animal, plant, food and object, in the styles photo and render, with a subject score of at least 0.5. That leaves 8,586. Each was resized on its shorter side and center-cropped to 1024 × 1024. Its alpha channel is the matte. No matting model ran.
2. Backgrounds. All 20,000 BG-20k images, resized and center-cropped to 1536 × 1536. That leaves a quarter of a 1024-pixel frame to spare on every side, so Stage B can pan and zoom without leaving the photo.
3. Disparity. Depth Anything V2 Large (depth-anything/Depth-Anything-V2-Large-hf) ran once on every image. The model cannot read transparency, so each cut-out was first pasted onto a fixed texture of soft noise around mid-gray.
4. Foreground cleanup. The matte, from alpha 0.04 up, was eroded by 5 pixels. Pixels in it below the 2nd percentile of disparity were dropped, because they are holes the model left, often in hair. What remains is the trusted core. Every pixel outside it takes the value of its nearest core pixel, smoothed with a Gaussian blur of sigma 3.
5. Storage. Every map was scaled to its own range and written as a 16-bit PNG.

Limitations

• The disparity is a model's estimate. It is relative, and it can be wrong, most visibly at thin structures such as hair.
• The foregrounds are generated. MAGICK made them with a text-to-image model and cut them out by chroma keying.
• The mattes carry a faint halo. Around most foregrounds, MAGICK's matte holds alpha under 0.04 well past the visible edge, covering 3.8 % of the square for the median foreground. Stage B composites it as it is, so each halo pixel carries under 4 % of the foreground's color and disparity into a frame.
• The subjects are uneven. Of the 8,586 foregrounds of the full library, 3,974 are people, 2,327 objects, 1,406 food, 483 plants and 396 animals, by the classifier's labels.
• The labels are not shipped. The classifier's subject and style of each foreground stay in the code repository, in backend/data/magick/predictions.csv, keyed by page_id, the part of a foreground id after __.
• Non-commercial use only. The license below follows from the sources.

Sources and license

The library is released under CC BY-NC 4.0, for non-commercial research. It holds images of two datasets, resized and cropped, and the output of one model:

part	source	license
foregrounds	MAGICK (Burgert et al., CVPR 2024)	CC BY-NC 4.0, as its project page states
backgrounds	BG-20k (Li et al., IJCV 2022)	MIT, on condition that papers using it cite Li et al.; each image's copyright stays with its owner
disparity	Depth Anything V2 Large (Yang et al., NeurIPS 2024)	weights CC BY-NC 4.0

Citation

If you use this dataset, please cite it:

@misc{danilov2026videobokeh,
  author       = {Danilov, Viacheslav and Dewil, Valéry and Arias, Pablo},
  title        = {{Video Bokeh}},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/vdanilov/video-bokeh}}
}