/ smooth-ot Public

Python implementation of smooth optimal transport.

# mblondel/smooth-ot

Switch branches/tags
Nothing to show

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

## Files

Failed to load latest commit information.
Type
Name
Commit time

# smooth-OT

Python implementation of smooth optimal transport.

## What is it?

Entropic regularization of optimal transport, as popularized by , is quickly emerging as a new standard. However, other strongly convex regularizations are possible. In particular, squared L2 regularization is interesting, since it typically results in sparse transportations plans. As shown in , OT with general strongly convex regularization can be solved using alternate Bregman projection algorithms. This package follows instead the dual and semi-dual approaches introduced in , which converge much faster in practice, especially when the regularization is low.

## Supported features

• L-BFGS solver for the smoothed dual
• L-BFGS solver for the smoothed semi-dual
• Regularizations: negative entropy, squared L2 norm

## Example

```import numpy as np

from smoothot.dual_solvers import solve_dual, solve_semi_dual
from smoothot.dual_solvers import NegEntropy, SquaredL2
from smoothot.dual_solvers import get_plan_from_dual, get_plan_from_semi_dual

# Generate artificial data.
rng = np.random.RandomState(0)
a = rng.rand(5)
b = rng.rand(8)
a /= np.sum(a)
b /= np.sum(b)
C = rng.rand(5, 8)

# Set regularization term.
# Can also use NegEntropy(gamma=1.0).
regul = SquaredL2(gamma=1.0)

# Solve smoothed dual.
alpha, beta = solve_dual(a, b, C, regul, max_iter=1000)
T = get_plan_from_dual(alpha, beta, C, regul)
print("Dual")
print("Value:", np.sum(T * C) + regul.Omega(T))
print("Sparsity:", np.sum(T != 0) / T.size)
print()

# Solve smoothed semi-dual.
alpha = solve_semi_dual(a, b, C, regul, max_iter=1000)
T = get_plan_from_semi_dual(alpha, b, C, regul)
print("Semi-dual")
print("Value:", np.sum(T * C) + regul.Omega(T))
print("Sparsity:", np.sum(T != 0) / T.size)
print()```

## Installation

This project can be installed from its git repository.

1. Obtain the sources by:

```git clone https://github.com/mblondel/smooth-ot.git
```

1. Install the dependencies:

```# via pip

pip install numpy scipy scikit-learn nose

# via conda

conda install numpy scipy scikit-learn nose
```
2. Install smooth-ot:

```cd smooth-ot
sudo python setup.py install
```

## References

  Marco Cuturi. Sinkhorn distances: Lightspeed computation of optimal transport. In: Proc. of NIPS 2013.
  Arnaud Dessein, Nicolas Papadakis, Jean-Luc Rouas. Regularized optimal transport and the rot mover’s distance. arXiv preprint arXiv:1610.06447, 2016.
  Mathieu Blondel, Vivien Seguy, Antoine Rolet. Smooth and Sparse Optimal Transport. In: Proc. of AISTATS 2018. [PDF]

## Author

• Mathieu Blondel, 2018

Python implementation of smooth optimal transport.

## Releases

No releases published

## Packages 0

No packages published

•
•