Scaling inverse problem solvers
beyond a single GPU
Modern inverse problem solvers deliver impressive reconstruction quality—but most are designed for problems that fit on a single GPU. We develop and benchmark distributed methods for images and volumes containing hundreds of millions to billions of pixels or voxels.
The challenge
Pushing the limits of scale for imaging inverse problems
State-of-the-art imaging inverse problem solvers increasingly combine physics-based models with learned priors. Yet nearly all are designed and evaluated on small-scale datasets, where the entire computation fits on a single GPU.
At scales of hundreds of millions to billions of pixels or voxels, this assumption breaks down. Memory limits and computation time become central challenges, fundamentally changing how these algorithms must be designed and executed.
| 01 ML & modeling challenges | 02 Systems & engineering challenges |
|---|---|
| Does reconstruction quality degrade? PSNR, SSIM, and scientific fidelity at scale with respect to single-GPU baselines. | How does runtime scale? Strong and weak scaling behaviors |
| Must learned priors be trained at full scale, or is patch-based training sufficient? Optimal training strategies for large-scale problems, including patch-based training and distributed training. | Where is the bottleneck? Compute, communication, memory. |
| What overlap is required? Reconstruction quality vs runtime tradeoff to avoid artifacts at patch boundaries. | Are GPUs efficiently utilized? Memory pressure, load balancing, and communication overhead. |
The distributed solvers
Distributed components for large-scale reconstruction with DeepInverse
Modern inverse problem solvers repeatedly alternate between physics-based updates and neural-network evaluations. DeepInverse distributes these core operations across multiple GPUs and nodes, enabling both inference and training on data for which computations cannot fit on a single device.
Explore the computation blocks →
deepinv.distributedThe benchmark
A reproducible benchmark for quality and scalability
Built with Benchopt, the benchmark connects imaging problems, distributed solvers, and cluster execution in a configuration-based evaluation framework.
Use Cases
Large-scale inverse problems where the data and reconstruction exceed 100 million pixels or voxels. Applications include high-resolution imaging, tomography, and radio interferometry.
See the use cases →Distributed Solvers
Distributed reconstruction algorithms based on deepinv.distributed.
Explore the solvers →Cluster execution
The benchmark is designed to run on SLURM-based clusters with multiple nodes and GPUs.
See the setup →The results
What scales, what breaks, and why
Our insights from large-scale experiments.
Communication under the hood: transfer vs wait
Separating pure data transfer from idle rank skew in distributed training and inference, and checking the result against real achievable bandwidth.
→02torch.compile: what it wins and where to put it
Denoiser and end-to-end PnP speedups from torch.compile, and why where you apply it matters as much as whether you do.
→03Scaling distributed plug-and-play inference
Understanding when distributed PnP reconstruction scales efficiently, and what eventually limits it.
→04Scaling distributed training for inverse problems
Why large-scale training is bounded by memory rather than compute, what activation checkpointing buys, and how the resulting runs scale across GPUs.
→