vdanilov/video-bokeh

Video Bokeh

Synthetic video for training and evaluating depth-aware bokeh. Every frame is composited from known layers, so its disparity, the soft matte of each object, its bokeh, its forward and backward optical flow and its occlusion match it by construction.

• The library, under library/: 8,586 cut-out foregrounds and 20,000 background photos, each with a disparity map. It holds no sequences. The code's generator composes new ones from it while a network trains, as many as the training asks for.
• The fixed set, under sequences/: 300 sequences the generator wrote once from the library's test split, for evaluation.
• The code, at github.com/ViacheslavDanilov/video-bokeh: the generator, the PyTorch loader and the download tools.

The code works in two stages. Stage A built the library once, from MAGICK and BG-20k images and Depth Anything V2 Large. Stage B, the generator, moves the foregrounds over a background at disparities it draws for each object and renders every stream of every frame.

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 the generator composed from both splits of the 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	Fixed set
Items	8,586	20,000	300 sequences
Size	1024 × 1024	1536 × 1536	80 frames at 1024 × 1024
Files	rgb.png, alpha.png, depth.png, meta.json	rgb.png, depth.png	7 streams of per-frame files
Shards	12	48	37
On disk	20.5 GB	94.4 GB	78.9 GB

In all, 97 shards hold 193.7 GB. depth.png holds disparity, not depth: larger values are closer. Every disparity map comes from Depth Anything V2 Large.

Train and test

Every asset is in the train split or the test split. The backgrounds follow BG-20k's own split. MAGICK has no split, so 10% of the foregrounds of each subject were drawn once, with a fixed seed, for the test split; the code repository lists them in test_foregrounds.txt.

	Train	Test
Foregrounds	7,727	859
Backgrounds	15,000	5,000

The generator draws from the train split unless it is told otherwise, by split="test" in the code's SequenceStream or --split test in its scenes.generate. The test split is held out for evaluation: the fixed set is made of it. There is no validation split: draw one from the train split, with seeds far from the training run's.

Quick start

It needs Python 3.13, uv and 114.9 GB of disk for the library, plus room for one shard of at most 2.0 GB.

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

fetch downloads the shards one at a time and unpacks each into the layout the generator reads. A second run downloads only the shards the first did not unpack.

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 the generator on that folder in memory. Each item is a new sequence, 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"),
    bokeh_strength=16.0,
)
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])

n_frames and size set a sequence's length and the side of its frames, and streams what an item carries. bokeh_strength is the bokeh's strength k: the blur radius, in pixels at a 1024-pixel width, of a point one unit of disparity from the focus. uv run python -m video_bokeh.loader.example --library-root data/library/da2-large trains a small network on the stream for 20 steps, and the project's README shows how to write sequences to disk instead.

Fixed set

sequences/ holds 300 sequences that the generator wrote once from the test split, for evaluation: none of their objects or backgrounds is in the train split. Each has 80 frames at 1024 × 1024 and 1 to 5 objects, and its bokeh is rendered at k = 16. fetch-sequences, run in the code's backend/ folder like fetch, needs 78.9 GB of disk, plus room for one shard of at most 2.3 GB:

uv run python -m video_bokeh.library.hub fetch-sequences --repo vdanilov/video-bokeh \
  --output data/fixed-set

data/fixed-set/
├── manifest.csv, objects.csv, run.json
└── sequences/<id>/
    ├── all_in_focus/, disparity/, alpha/, bokeh/ (with focus.json)
    └── flow/, flow_back/, occlusion/

File	Frames	Mode	Type	Values
all_in_focus/<frame>.png	all	RGB	uint8	the frame with nothing blurred
disparity/<frame>.png	all	I;16	uint16	disparity in [0, 1] times 65535, larger closer, on one axis for every sequence, the background under 0.05
alpha/<frame>.tif	all	a page per object	uint8	each object's soft matte, 0 to 255
bokeh/<frame>.png	all	RGB	uint8	the frame as the layered renderer blurred it
flow/<frame>.png	all but the last	RGB	uint16	the optical flow to the next frame, KITTI-encoded
flow_back/<frame>.png	all but the first	RGB	uint16	the optical flow to the previous frame, KITTI-encoded
occlusion/<frame>.png	all but the last	L	uint8	255 where the next frame does not show the surface

• The flow is exact. Every layer moves by a known transform, so the flow follows the front-most surface at each pixel. KITTI's encoding stores red u · 64 + 2¹⁵, green v · 64 + 2¹⁵ and blue 1 where valid, so read it with a 16-bit reader such as the code's read_flow_png. The occlusion mask belongs to the forward flow; the backward flow has none.
• bokeh/focus.json names the object in focus by its alpha page, or null, gives each frame's in-focus disparity as zf, and records the renderer and its settings.
• The run's records sit beside the shards. manifest.csv gives each sequence's seed, object count and background, objects.csv each object's foreground and trajectory, and run.json the settings. With them, and code whose sampling has not changed since, the code's scenes.generate writes the same sequences again with --layers, and its render.run renders their bokeh from those layers at another strength or focus.
• A shard holds one sample per sequence, its files named <id>.<stream>.<frame>, with <id>.focus.json and <id>.json, the sequence's rows of the records.

The code repository's dataset layout describes every stream in full.

Read the files without the code

A library item is plain PNG, read with Pillow and NumPy:

import numpy as np
from PIL import Image

item = "data/library/da2-large/foregrounds/<id>"  # a folder `fetch` wrote
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 streams the shards from the Hub with no download, one sample per item, which is enough to inspect them:

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__

Read the fixed set with fetch-sequences, not datasets. Its sequences subset has a row per sequence, but Pillow decodes a flow file as 8-bit color and an alpha file as its first page alone, and the first row comes only after a few whole sequences.

Library files

The files of an item, as fetch writes them under data/library/da2-large/:

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 to 0 and its largest to 65535. Values cannot be compared across items, and no map holds metric depth. The generator stretches each map into the band of disparity it draws for the object, so only the shape inside a map matters.
• A foreground's disparity covers the whole square. Inside the trusted core (step 4 of How it was built) it is the estimator's. Everywhere else, the matte's edge and the holes the cleanup dropped included, it is copied from the nearest core pixel and blurred, since the generator reads it wherever the matte is above 0.
• Ids name the source image, with __ for the slash. A foreground id is MAGICK's image path without its extension. A background id is BG-20k's split folder and file name, train__h_… or testval__h_….
• meta.json records the estimator, the source image, the cleanup settings 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.

Files in this repository

README.md
assets/preview.jpg
assets/preview.mp4
library/index.json
library/foregrounds/train-00000.tar … train-00009.tar
library/foregrounds/test-00000.tar … test-00001.tar
library/backgrounds/train-00000.tar … train-00035.tar
library/backgrounds/test-00000.tar … test-00011.tar
sequences/index.json
sequences/objects.csv
sequences/run.json
sequences/manifest.csv
sequences/test-00000.tar … test-00036.tar

• A shard is a plain tar in WebDataset's layout, of whole items of one split. An item's files share its id, as <id>.rgb.png, <id>.alpha.png, <id>.depth.png and <id>.json. The images are PNG already, so the tar is not compressed again.
• Each library item also holds <id>.depth_preview.jpg, its disparity in color, for the Hub's viewer. fetch leaves it out.
• library/index.json lists each kind's shards with their split, item count and bytes. fetch reads it first.

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 the generator 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 bokeh is a renderer's, not a lens's. The project's layered renderer blurs each layer by its disparity, so a network trained on it learns that renderer.
• 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. The generator composites it as it is, so each halo pixel carries under 4% of the foreground's color and disparity into a frame.
• The split is by image, not by prompt. MAGICK made several images from some prompts, and 144 of the 859 test foregrounds share their prompt, word for word, with a train foreground.
• The subjects are uneven. Of the 8,586 foregrounds, 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: they stay in the code repository, in predictions.csv, keyed by page_id, the part of a foreground id after __.

Sources and license

The dataset is released under CC BY-NC 4.0, for non-commercial research only, as its sources require. 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}}
}