π Geometric Computer Vision Library for Spatial AI
Python artificial-intelligencecomputer-visiondeep-learninghacktoberfestimage-processingmachine-learningneural-networkpythonpytorchroboticsspatial-ai
# LICENSE HEADER MANAGED BY add-license-header
#
# Copyright 2018 Kornia Team
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""End-to-end augmentation *pipeline* throughput: kornia vs torchvision vs albumentations.
Where ``cross_library.py`` times single ops, this times a realistic multi-op pipeline applied
to a whole batch β the shape training loops actually run. It exists to measure the regime
kornia is built to lead: **GPU-batched, differentiable augmentation compiled end-to-end**.
Reading the results honestly:
- **albumentations** applies the pipeline to single ``uint8`` HWC numpy images in a Python loop
(its home turf: CPU, integer, per-image). It has no batch or GPU or gradient path.
- **torchvision v2** and **kornia** apply the pipeline to a batched ``float`` ``BCHW`` tensor,
and both run on GPU. Neither albumentations nor torchvision v2's default transforms are
differentiable end-to-end; kornia's are.
- **kornia (compiled)** wraps the same pipeline in ``torch.compile``. On GPU the pointwise ops
fuse; this is where kornia is designed to win. The pipeline is chosen from the compile-clean
op set (see the per-op ``test_dynamo`` tests), and ``ColorJitter`` is given a fixed ``order``
so the whole pipeline is fullgraph-compilable.
The point is not to win the CPU/uint8 single-image race (albumentations owns that β that is what
the planned ``kornia-rs`` backend targets). It is to quantify the GPU-batched, differentiable,
compiled pipeline where kornia leads. Record the CUDA row on a datacenter GPU for headline
numbers; Jetson/CPU rows are directional.
Usage:
python benchmarks/augmentation/pipeline.py [--batch 32] [--size 224] [--device cpu] [--compile]
"""
from __future__ import annotations
import argparse
import math
import platform
import subprocess
import numpy as np
import torch
import torch.utils.benchmark as bench
from torch import nn
def _throughput_us(fn, min_run_time: float = 2.0) -> float:
return bench.Timer(stmt="fn()", globals={"fn": fn}).blocked_autorange(min_run_time=min_run_time).median * 1e6
def _git_commit() -> str:
try:
return subprocess.check_output(["git", "rev-parse", "--short", "HEAD"], text=True).strip() # noqa: S607
except Exception:
return "unknown"
def build_kornia(device: torch.device) -> nn.Module:
import kornia.augmentation as K
# p=1.0 everywhere for a deterministic, apples-to-apples timing of the applied work.
# A fixed `order` keeps ColorJitter (and hence the whole pipeline) fullgraph-compilable.
return nn.Sequential(
K.RandomHorizontalFlip(p=1.0),
K.RandomVerticalFlip(p=1.0),
K.ColorJitter(0.2, 0.2, 0.2, 0.1, p=1.0, order=[0, 1, 2, 3]),
K.RandomBrightness((1.2, 1.2), p=1.0),
K.RandomContrast((1.2, 1.2), p=1.0),
K.RandomGaussianNoise(mean=0.0, std=0.05, p=1.0),
).to(device)
def build_torchvision() -> object:
import torchvision.transforms.v2 as T2
return T2.Compose(
[
T2.RandomHorizontalFlip(p=1.0),
T2.RandomVerticalFlip(p=1.0),
T2.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
T2.GaussianNoise(mean=0.0, sigma=0.05),
]
)
def build_albumentations() -> object:
import albumentations as A
return A.Compose(
[
A.HorizontalFlip(p=1.0),
A.VerticalFlip(p=1.0),
A.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1, p=1.0),
A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=1.0),
A.GaussNoise(p=1.0),
]
)
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--batch", type=int, default=32)
parser.add_argument("--size", type=int, default=224)
parser.add_argument("--device", type=str, default="cpu")
parser.add_argument("--threads", type=int, default=4)
parser.add_argument("--compile", action="store_true", help="also time the torch.compile'd kornia pipeline")
parser.add_argument("--half", action="store_true", help="run in float16 (the AMP training regime)")
args = parser.parse_args()
torch.set_num_threads(args.threads)
device = torch.device(args.device)
b, h, w = args.batch, args.size, args.size
dtype = torch.float16 if args.half else torch.float32
rng = np.random.default_rng(0)
batch_f = torch.rand(b, 3, h, w, device=device, dtype=dtype)
batch_u8 = [(rng.random((h, w, 3)) * 255).astype(np.uint8) for _ in range(b)]
def thr(t: float) -> float:
return b / (t / 1e6) if not math.isnan(t) else float("nan")
print(f"# pipeline benchmark β commit {_git_commit()} β {platform.platform()}")
if device.type == "cuda":
print(f"# CUDA device: {torch.cuda.get_device_name(0)}")
dtype_name = "float16" if args.half else "float32"
print(
f"batch={b}, {h}x{w}, device={device}, dtype={dtype_name}, "
f"threads={args.threads} β throughput img/s (higher is better)"
)
print("-" * 84)
results: dict[str, float] = {}
kornia_pipe = build_kornia(device).to(dtype)
results["kornia (eager)"] = thr(_throughput_us(lambda: kornia_pipe(batch_f)))
if args.compile:
torch._dynamo.reset()
compiled = torch.compile(kornia_pipe)
compiled(batch_f) # warmup / trigger compilation
results["kornia (compiled)"] = thr(_throughput_us(lambda: compiled(batch_f)))
try:
tv = build_torchvision()
results["torchvision v2"] = thr(_throughput_us(lambda: tv(batch_f)))
except Exception as e: # pragma: no cover - optional dependency / version drift
print(f"# torchvision skipped: {e}")
try:
albu = build_albumentations()
results["albumentations"] = thr(_throughput_us(lambda: [albu(image=im)["image"] for im in batch_u8]))
except Exception as e: # pragma: no cover - optional dependency
print(f"# albumentations skipped: {e}")
width = max(len(k) for k in results)
for name, value in results.items():
print(f"{name:<{width}} | {value:9.0f} img/s")
if __name__ == "__main__":
main()