FlashBEV (ECCV 2026)

Where FlashBEV fits: the camera-based BEV perception pipeline — FlashBEV is a drop-in replacement for the view-transformation stage of a camera-based BEV perception system.

A drop-in, numerically exact view transformation for camera-based BEV perception (3D object detection, map segmentation) that projects features on the fly and materializes no intermediate tensors in HBM — peak memory is the output alone, independent of height bins. The large speedups follow from that reduced memory traffic.

Abstract

Sampling-based view transformation (Sampling-VT) maps multi-camera image features into a bird's-eye-view grid, but its standard tensorized implementation materializes large intermediate tensors over BEV cells, cameras, and height bins — so memory and latency scale poorly with vertical resolution and camera count.

FlashBEV is a fully fused, IO-aware execution strategy that is mathematically equivalent to Tensorized Sampling-VT (same operator output) while substantially reducing global memory traffic and kernel-launch overhead. It reduces the operator's peak memory to O(BCXY) (output only) — effectively independent of the number of height bins — and delivers significant inference-latency speedups. This unlocks higher BEV range/resolution and vertical discretization within fixed deployment budgets on memory-constrained devices where tensorized execution would otherwise be infeasible.

Same math, different execution. FlashBEV matches the tensorized baseline bit-for-bit on both output and gradients, so it is a drop-in replacement that needs no retraining.

Background: two ways to build a BEV

View transformation (VT) lifts features from multiple camera images into a shared bird's-eye-view grid. Designs fall into two families:

Splatting-VT — forward-projects (scatters) image features into BEV. Memory-friendly with index-based pooling, but tends to give geometry-dependent, uneven coverage.
Sampling-VT — backward-queries (gathers) features at each BEV location. Dense, continuous coverage — attractive for high-resolution, long-range perception.

Splatting-VT vs Sampling-VT — Splatting-VT (left) forward-projects/scatters image features into BEV; Sampling-VT (right) backward-queries/gathers features at each BEV location.

Sampling-VT's density is what makes it powerful — but its standard tensorized implementation pays for that density in memory and latency.

FlashBEV: same math, different execution

FlashBEV recasts Sampling-VT as a single fused, IO-aware kernel: it computes projection coordinates on the fly and accumulates straight into the BEV output, so no intermediate tensor is ever allocated in HBM. Peak memory collapses to O(BCXY) (output only), independent of the number of height bins. Because it no longer streams large intermediates through global memory, it also runs ~5× faster — the speedup is a consequence of the memory-aware execution, not a separate trick. It is numerically identical to Tensorized Sampling-VT (bit-exact output and gradients) — a drop-in replacement that needs no retraining.

FlashBEV fused-kernel overview — FlashBEV fuses projection, sampling, and reduction into one IO-aware kernel — no height-dependent intermediate tensors are ever materialized.

On the SimpleBEV reference config (RTX A6000): >37× lower peak memory, ≈5.2× faster forward, numerically exact. FlashBEV slots into any sampling-based VT pipeline (SimpleBEV- and BEVFormer-style); the same idea transfers to BEVFormer's Spatial Cross-Attention (FlashSCA).

Highlights

🧠 Zero intermediate HBM allocation — projection·sampling·reduction fuse on-chip; nothing height-dependent hits global memory. Peak memory O(BCXY) (output only), independent of height bins (Z) → >37× lower peak memory.
🚀 Faster as a consequence — cutting HBM traffic and kernel launches yields ~5× faster forward VT (backward too).
🎯 Numerically exact — cosine similarity 1.000000 vs. the tensorized baseline.
⚡ Deploys in TensorRT as a custom plugin (exact, zero max error).
🔁 Transfers across operators — applied to BEVFormer's SCA (FlashSCA).
🧩 Drop-in & training-compatible — no retraining, no accuracy change.

Results

View transformation at the SimpleBEV reference config (BEV 200×200, Z=8, C=128), RTX A6000, FP32:

Method	Fwd latency	Fwd peak mem	Bwd latency	Bwd peak mem
Tensorized Sampling-VT	9.18 ms	1971.94 MB	17.90 ms	1174.86 MB
FlashBEV (ours)	1.77 ms	52.82 MB	3.27 ms	105.63 MB
improvement	≈5.2× faster	≈37× smaller	≈5.5× faster	≈11× smaller

Memory and latency vs number of height bins — Peak memory and latency vs. height bins (Z). Tensorized Sampling-VT grows roughly linearly with Z; FlashBEV stays flat — memory is essentially independent of Z.

VT speedup across six GPUs — VT speedup (Tensorized / FlashBEV) across six GPUs, from datacenter (A6000, H200) to edge (Jetson Orin Nano): forward 3.3–6.2×, backward 5.2–7.9×.

Usage

FlashBEV's view transformation is a drop-in nn.Module:

import torch
from flashbev import SamplingVT

# BEV grid as (min, max, cell size) per axis; reference config -> 200 x 200 x 8
vt = SamplingVT(
    grid_x=(-50.0, 50.0, 0.5),          # X -> 200 cells
    grid_y=(-50.0, 50.0, 0.5),          # Y -> 200 cells
    grid_z=(-5.0, 5.0, 1.25),           # Z -> 8 height bins
    image_height=448, image_width=800,  # original image size (for projection)
    fuse_projection=True,
).cuda()

# from your 2D backbone + camera calibration
features_pv = torch.randn(1, 6, 128, 56, 100, device="cuda")  # [B, N, C, H, W]
projection  = torch.randn(1, 6, 3, 4,        device="cuda")   # [B, N, 3, 4]

bev = vt(projection, features_pv)   # -> [B, C, X, Y] = [1, 128, 200, 200]
# feed `bev` into your BEV encoder + detection / segmentation heads

BibTeX

@inproceedings{yokokawa2026flashbev,
  title     = {FlashBEV: Fast and Memory-Efficient Exact BEV Transformation with IO-Awareness},
  author    = {Yokokawa, Shunsuke and Kasahara, Hironori},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2026},
  eprint    = {2607.10071},
  archivePrefix = {arXiv},
  primaryClass = {cs.CV}
}