💻 computer science

Efficient Transferable Optimal Transport via Min-Sliced Transport Plans

This paper introduces a transferable Min-Sliced Transport Plan framework that theoretically guarantees the stability of learned optimal slicers under distributional shifts and empirically demonstrates its effectiveness in achieving efficient, amortized transport for tasks like point cloud alignment and generative modeling.

Original authors: Xinran Liu, Elaheh Akbari, Rocio Diaz Martin, Navid NaderiAlizadeh, Soheil Kolouri

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xinran Liu, Elaheh Akbari, Rocio Diaz Martin, Navid NaderiAlizadeh, Soheil Kolouri

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Moving Mountains Without Breaking a Sweat

Imagine you have two piles of sand. One pile is shaped like a mountain, and the other is shaped like a valley. Your goal is to move the sand from the mountain to the valley to make them match perfectly. In the world of math and computer science, this is called Optimal Transport (OT). It's about finding the most efficient way to move "stuff" from one place to another.

However, doing this math is incredibly hard and slow, especially when you have millions of grains of sand (data points). It's like trying to move a mountain grain-by-grain with a tiny spoon.

The Problem: The "Do-It-All-Again" Trap

Recently, scientists found a shortcut called Sliced Transport. Instead of looking at the whole 3D mountain, they slice it into thin, 1D strips (like slicing a loaf of bread). They solve the problem for each slice, which is much faster.

But there was a catch: Every time the shape of the mountain changed slightly, you had to start from scratch.

Scenario: Imagine you are a delivery driver. You figure out the fastest route to deliver packages in New York City. The next day, the traffic is slightly different, or the delivery addresses shift a tiny bit. Current methods would make you forget your old route and calculate a brand new one from zero, even though the new route is 99% similar to the old one. This is a waste of time and energy.

The Solution: The "Smart Slicer" (Min-STP)

This paper introduces a new method called Min-Sliced Transport Plans (min-STP). Think of it as teaching the computer to learn a "smart slicer" (a special tool that cuts the data) that can be reused.

Here is how it works, using three main ideas:

1. The Transferable "Slicer" (The Magic Knife)

Imagine you have a magic knife that knows exactly how to slice a loaf of bread so that the pieces line up perfectly with another loaf.

Old Way: If you get a slightly different loaf of bread, you have to invent a new knife from scratch.
New Way (This Paper): The paper proves that if the new loaf is similar to the old one, your existing magic knife still works almost perfectly. You don't need to invent a new one; you just tweak the old one slightly.
The Claim: The authors mathematically proved that if two data sets are "close" to each other, the best tool (slicer) for the first one is also very close to the best tool for the second one. This allows the computer to reuse its previous work, saving massive amounts of time.

2. The "Smooth Sorting" Trick (LapSum)

To make the math work, the computer needs to sort the sliced data. Sorting is usually a "hard" step that confuses computers trying to learn (it's like trying to slide a block of ice; it's slippery and hard to control).

The Innovation: The authors use a technique called LapSum. Imagine instead of sorting hard blocks, you put them in a box of soft, fluffy marshmallows. The blocks can still be sorted, but the "fluff" makes the process smooth and easy for the computer to learn from. This allows the computer to learn the best "knife" very quickly using standard learning techniques.

3. The "Tasting Spoon" (Mini-Batch Training)

Usually, to learn the best knife, you have to taste the entire mountain of sand, which takes forever.

The Innovation: The authors show you can learn just as well by tasting a tiny spoonful (a "mini-batch") of the sand at a time. They proved mathematically that if you taste enough small spoonfuls, you get the same result as tasting the whole mountain, but much faster. This makes the method scalable to huge datasets.

What Did They Actually Do? (The Experiments)

The authors tested this "Smart Slicer" in three specific areas to prove it works:

Point Cloud Alignment (3D Shapes): They used 3D models of objects (like chairs, desks, and sofas). They showed that once the computer learned how to align a "Chair" to a "Desk," it could instantly apply that knowledge to align a "Chair" to a "Bed" with very little extra work. It was much faster than starting over.
Flow-Based Generation (Creating New Shapes): They used the method to generate new 3D shapes (like creating a new chair based on existing ones). The method created high-quality shapes faster than previous methods.
Image Translation (Changing Faces): They tried changing images of adults into images of children (and vice versa). By reusing the "slicer" learned from one batch of faces to the next, they achieved good results without recalculating everything from scratch every time.

Summary

In simple terms, this paper teaches computers how to stop reinventing the wheel.

Before: "I have a new problem? Okay, I will forget everything I learned and solve this from zero."
After (This Paper): "I have a new problem that looks a lot like the last one? Great! I'll just tweak my old solution. It's faster, cheaper, and just as accurate."

They proved this works mathematically and showed it works in practice for 3D shapes and images, making complex data matching much more efficient.

Technical Summary: Efficient Transferable Optimal Transport via Min-Sliced Transport Plans

Problem Statement

Optimal Transport (OT) provides a principled framework for establishing correspondences between probability distributions, with applications ranging from domain adaptation and generative modeling to single-cell analysis and shape matching. However, computing exact OT plans is computationally expensive, scaling cubically with the number of samples. While "sliced" methods have emerged as efficient alternatives by projecting high-dimensional distributions onto one-dimensional marginals, existing approaches suffer from two primary limitations:

Lack of Explicit Plans: Many sliced methods compute distances but fail to recover explicit transportation plans.
Inefficiency in Repeated Tasks: Current efficient OT solvers are designed for single-instance problems. In real-world scenarios involving evolving or structurally similar distributions (e.g., developmental biology or sequential image translation), valuable information from prior solutions is discarded, forcing solvers to recompute everything from scratch.

The central question addressed is whether a "slicer" (a projection function) learned on one pair of distributions can be effectively transferred to produce optimal transport plans for unseen, related distribution pairs.

Methodology

The paper proposes the Min-Sliced Transport Plan (min-STP) framework, which integrates learnable generalized slicers with a theoretical foundation for transferability.

1. Min-Sliced Transport Plan (min-STP)

The framework builds upon the Sliced Transportation Plan (STP), which lifts a one-dimensional optimal transport plan from a projected space back to the ambient space via an injective map $f$ . To find the most efficient plan, the method minimizes the transport cost over a class of parametric functions $\mathcal{F}$ :
$\text{min-STP}_p(\mu, \nu) = \min_{f \in \mathcal{F}} \text{STP}_p(\mu, \nu; f)$
This formulation coincides with min-SWGG and Differentiable Generalized Sliced Wasserstein Plans (DGSWP) in specific cases but is extended here to support transferability.

2. Theoretical Transferability

The core theoretical contribution is a transferability theorem. The authors establish that optimized slicers are stable under small perturbations of the source and target distributions.

Perturbation Model: They introduce a smoothed objective $J_\eta$ by adding Laplace noise to the slicer projections. This ensures injectivity of the projection and enables differentiable sorting.
Stability Result: Using Berge's Maximum Theorem and the compactness of the function class $\mathcal{F}$ , they prove that if two distribution pairs $(\mu_1, \nu_1)$ and $(\mu_2, \nu_2)$ are close in Wasserstein distance (i.e., $OT_p(\mu_1, \mu_2) + OT_p(\nu_1, \nu_2) < \tau$ ), then their optimal slicers $f_1^*$ and $f_2^*$ are close in the uniform norm ( $\|f_1^* - f_2^*\|_\infty < \epsilon$ ).
Implication: This provides the first theoretical foundation for amortized slicer reuse, allowing a slicer learned on a source task to serve as an effective initialization or prior for a related target task.

3. Computational Implementation: LapSum and Minibatching

To achieve scalability and differentiability, the method employs two key techniques:

LapSum (Smoothed Sorting): Instead of using Gaussian noise and control variates (as in DGSWP), which can suffer from high variance, the authors utilize LapSum. By injecting Laplace noise, they derive a closed-form expression for the inverse cumulative distribution function (CDF) of the smoothed projections. This allows for differentiable sorting and rank estimation with $O(n \log n)$ complexity and $O(n)$ memory, avoiding the need to repeatedly solve 1D OT problems.
Minibatch Formulation: To handle large-scale datasets, the authors introduce a minibatch version of the min-STP loss. They provide statistical rates proving that the minibatch objective converges to the full-batch objective as the batch size increases, with bounds depending on the quantile moduli of the projected distributions.

Key Contributions

Transferability Characterization: The paper characterizes the transferability of optimized slicers, proving that slicers remain close under small source-target perturbations, enabling efficient reuse across related tasks.
Statistical Rates for Minibatches: The authors derive finite-sample statistical rates for slicers optimized using source-target minibatches, providing theoretical guarantees for the scalability of the approach.
Empirical Validation: The method is demonstrated to achieve strong one-shot matching performance and facilitate amortized training in three distinct domains: point cloud alignment, mean-flow generation, and unpaired image-to-image translation.

Experimental Results

The authors evaluated the transferable min-STP framework on several benchmarks:

Gradual Drift (Synthetic): On a sequence of gradually changing distribution pairs (rotations and zooms), a slicer pretrained on a previous task ( $t-1$ ) started from a significantly lower objective cost than random initialization when applied to task $t$ . This confirmed that the learned slicer captures persistent geometric structures.
Point Cloud Alignment (ModelNet10): An amortized slicer trained on all training pairs of object categories (e.g., desk, sofa) was tested on unseen pairs. The amortized min-STP achieved Pearson correlations with exact OT comparable to per-pair min-STP (which trains a separate slicer for each pair) and significantly outperformed baselines like random slicers and Wasserstein Wormhole.
Flow-Based Generation (ShapeNet): In a single-step generation setting using MeanFlow, min-STP balanced low computation time with low Wasserstein distance ( $W_2$ ) to ground truth, outperforming baselines in the efficiency-accuracy trade-off.
Image Translation (FFHQ): In unpaired image-to-image translation (Adult-to-Child), the transferable min-STP structure allowed for efficient training where the transport plan was computed via a shared slicer, unlike other methods that required recomputing plans for every batch.

Significance and Claims

The paper claims to provide the first theoretical foundation for amortized slicer reuse in optimal transport. By establishing a formal link between distributional similarity and slicer proximity, the work enables the transition from isolated OT computations to adaptive, amortized OT across related problems.

The significance lies in:

Efficiency: Eliminating the need to recompute transport plans from scratch for related distribution pairs.
Scalability: The combination of LapSum and minibatch training makes large-scale OT feasible without sacrificing the quality of the transport plan.
Generalization: Demonstrating that a single, geometry-aware slicer can generalize across diverse domains (3D shapes, images, and synthetic distributions), opening avenues for scalable OT in dynamic, multi-domain settings.

The authors note that their theoretical results currently apply to discrete settings and that the method relies on the assumption that source-target pairs are sufficiently similar for the transfer to be effective.