Entropic Regularization of Optimal Transport

Important: Please read the installation page for details about how to install the toolboxes. $\newcommand{\dotp}[2]{\langle #1, #2 \rangle}$ $\newcommand{\enscond}[2]{\lbrace #1, #2 \rbrace}$ $\newcommand{\pd}[2]{ \frac{ \partial #1}{\partial #2} }$ $\newcommand{\umin}[1]{\underset{#1}{\min}\;}$ $\newcommand{\umax}[1]{\underset{#1}{\max}\;}$ $\newcommand{\umin}[1]{\underset{#1}{\min}\;}$ $\newcommand{\uargmin}[1]{\underset{#1}{argmin}\;}$ $\newcommand{\norm}[1]{\|#1\|}$ $\newcommand{\abs}[1]{\left|#1\right|}$ $\newcommand{\choice}[1]{ \left\{ \begin{array}{l} #1 \end{array} \right. }$ $\newcommand{\pa}[1]{\left(#1\right)}$ $\newcommand{\diag}[1]{{diag}\left( #1 \right)}$ $\newcommand{\qandq}{\quad\text{and}\quad}$ $\newcommand{\qwhereq}{\quad\text{where}\quad}$ $\newcommand{\qifq}{ \quad \text{if} \quad }$ $\newcommand{\qarrq}{ \quad \Longrightarrow \quad }$ $\newcommand{\ZZ}{\mathbb{Z}}$ $\newcommand{\CC}{\mathbb{C}}$ $\newcommand{\RR}{\mathbb{R}}$ $\newcommand{\EE}{\mathbb{E}}$ $\newcommand{\Zz}{\mathcal{Z}}$ $\newcommand{\Ww}{\mathcal{W}}$ $\newcommand{\Vv}{\mathcal{V}}$ $\newcommand{\Nn}{\mathcal{N}}$ $\newcommand{\NN}{\mathcal{N}}$ $\newcommand{\Hh}{\mathcal{H}}$ $\newcommand{\Bb}{\mathcal{B}}$ $\newcommand{\Ee}{\mathcal{E}}$ $\newcommand{\Cc}{\mathcal{C}}$ $\newcommand{\Gg}{\mathcal{G}}$ $\newcommand{\Ss}{\mathcal{S}}$ $\newcommand{\Pp}{\mathcal{P}}$ $\newcommand{\Ff}{\mathcal{F}}$ $\newcommand{\Xx}{\mathcal{X}}$ $\newcommand{\Mm}{\mathcal{M}}$ $\newcommand{\Ii}{\mathcal{I}}$ $\newcommand{\Dd}{\mathcal{D}}$ $\newcommand{\Ll}{\mathcal{L}}$ $\newcommand{\Tt}{\mathcal{T}}$ $\newcommand{\si}{\sigma}$ $\newcommand{\al}{\alpha}$ $\newcommand{\la}{\lambda}$ $\newcommand{\ga}{\gamma}$ $\newcommand{\Ga}{\Gamma}$ $\newcommand{\La}{\Lambda}$ $\newcommand{\si}{\sigma}$ $\newcommand{\Si}{\Sigma}$ $\newcommand{\be}{\beta}$ $\newcommand{\de}{\delta}$ $\newcommand{\De}{\Delta}$ $\newcommand{\phi}{\varphi}$ $\newcommand{\th}{\theta}$ $\newcommand{\om}{\omega}$ $\newcommand{\Om}{\Omega}$ $\newcommand{\eqdef}{\equiv}$

This numerical tours exposes the general methodology of regularizing the optimal transport (OT) linear program using entropy. This allows to derive fast computation algorithm based on iterative projections according to a Kulback-Leiber divergence. $$ \DeclareMathOperator{\KL}{KL} \newcommand{\KLdiv}[2]{\KL\pa{#1 | #2}} \newcommand{\KLproj}{P^{\tiny\KL}} \def\ones{\mathbb{I}} $$

In [1]:
from __future__ import division

import numpy as np
import matplotlib.pyplot as plt
import scipy as scp
import pylab as pyl

import warnings
warnings.filterwarnings('ignore')

%matplotlib inline
%load_ext autoreload
%autoreload 2

Entropic Regularization of Optimal Transport

We consider two input histograms $p,q \in \Si_N$, where we denote the simplex in $\RR^N$ $$ \Si_{N} \eqdef \enscond{ p \in (\RR^+)^N }{ \sum_i p_i = 1 }. $$ We consider the following discrete regularized transport $$ W_\ga(p,q) \eqdef \umin{\pi \in \Pi(p,q)} \dotp{C}{\pi} - \ga E(\pi). $$ where the polytope of coupling is defined as $$ \Pi(p,q) \eqdef \enscond{\pi \in (\RR^+)^{N \times N}}{ \pi \ones = p, \pi^T \ones = q }, $$ where $ \ones \eqdef (1,\ldots,1)^T \in \RR^N $, and for $\pi \in (\RR^+)^{N \times N}$, we define its entropy as $$ E(\pi) \eqdef - \sum_{i,j} \pi_{i,j} ( \log(\pi_{i,j}) - 1). $$

When $\ga=0$ one recovers the classical (discrete) optimal transport. We refer to the monograph Villani for more details about OT. The idea of regularizing transport to allows for faster computation is introduced in Cuturi.

Here the matrix $C \in (\RR^+)^{N \times N} $ defines the ground cost, i.e. $C_{i,j}$ is the cost of moving mass from a bin indexed by $i$ to a bin indexed by $j$.

The regularized transportation problem can be re-written as a projection $$ W_\ga(p,q) = \ga \umin{\pi \in \Pi(p,q)} \KLdiv{\pi}{\xi} \qwhereq \xi_{i,j} = e^{ -\frac{C_{i,j}}{\ga} } $$ of $\xi$ according to the Kullback-Leibler divergence. The Kullback-Leibler divergence between $\pi, \xi \in (\RR^+)^P$ is $$ \KLdiv{\pi}{\xi} = \sum_{i,j} \pi_{i,j} \pa{ \log\pa{ \frac{\pi_{i,j}}{\xi_{i,j}} } - 1}. $$

This interpretation of regularized transport as a KL projection and its numerical applications are detailed in BenamouEtAl.

Given a convex set $\Cc \subset \RR^N$, the projection according to the Kullback-Leiber divergence is defined as $$ \KLproj_\Cc(\xi) = \uargmin{ \pi \in \Cc } \KLdiv{\pi}{\xi}. $$

Iterative Bregman Projection Algorithm

Given affine constraint sets $ (\Cc_1,\ldots,\Cc_K) $, we aim at computing $$ \KLproj_\Cc(\xi) \qwhereq \Cc = \Cc_1 \cap \ldots \cap \Cc_K. $$

This can be achieved, starting by $\pi_0=\xi$, by iterating $$ \forall \ell \geq 0, \quad \pi_{\ell+1} = \KLproj_{\Cc_\ell}(\pi_\ell), $$ where the index of the constraints should be understood modulo $K$, i.e. we set $ \Cc_{\ell+K}=\Cc_\ell $.

One can indeed show that $\pi_\ell \rightarrow \KLproj_\Cc(\bar \pi)$. We refer to BauschkeLewis for more details about this algorithm and its extension to compute the projection on the intersection of convex sets (Dikstra algorithm).

Iterative Projection for Regularized Transport aka Sinkhorn's Algorithm

We can re-cast the regularized optimal transport problem within this framework by introducing $$ \Cc_1 \eqdef \enscond{\pi \in (\RR^+)^{N \times N} }{\pi \ones = p} \qandq \Cc_2 \eqdef \enscond{\pi \in (\RR^+)^{N \times N} }{\pi^T \ones = q}. $$

The KL projection on $\Cc_1$ sets are easily computed by divisive normalization of rows. Indeed, denoting $ \pi = \KLproj_{\Cc_1}(\bar \pi) $, one has $$ \forall (i,j), \quad \pi_{i,j} = \frac{ p_i \bar\pi_{i,j} }{ \sum_{s} \bar\pi_{i,s} } $$ and similarely for $\KLproj_{\Cc_1}(\bar \pi) $ by replacing rows by colums.

A fundamental remark is that, if $\bar\pi = \diag{a} \xi \diag{b}$ (a so-called diagonal scaling of the kernel $\xi$), then one has $$ \KLproj_{\Cc_1}(\bar \pi) = \diag{\tilde a} \xi \diag{b} \qandq \KLproj_{\Cc_2}(\bar \pi) = \diag{a} \xi \diag{\tilde b}$$ where the new scaling reads $$ \tilde a = \frac{p}{\xi(b)} \qandq \tilde b = \frac{q}{\xi^T(a)} $$ where $\frac{\cdot}{\cdot}$ is entry-wise division.

This means that the iterates of Bregman iterative projections, starting with $ a_0 \eqdef \ones $ always have the form $ \pi_\ell = \diag{a_\ell} \xi \diag{b_\ell} $ and these diagonal scaling weights are updated as follow $$ a_{\ell+1} \eqdef \frac{p}{\xi(b_\ell)} \qandq b_{\ell+1} \eqdef \frac{q}{\xi^T(a_{\ell+1})}. $$ This algorithm is in fact the well known Sinkhorn algorithm Sinkhorn.

Transport Between Point Clouds

We first test the method for two input measures that are uniform measures (i.e. constant histograms) supported on two point clouds (that do not necessarily have the same size).

We thus first load two points clouds $x=(x_i)_{i=1}^{N_1}, y=(y_i)_{i=1}^{N_2}, $ where $x_i, y_i \in \RR^2$.

Number of points in each cloud.

In [2]:
N = [300,200]

Dimension of the clouds.

In [3]:
d = 2

Point cloud $x$, of $N_1$ points inside a square.

In [4]:
x = np.random.rand(2,N[0])-.5

Point cloud $y$, of $N_2$ points inside an anulus.

In [5]:
theta = 2*np.pi*np.random.rand(1,N[1])
r = .8 + .2*np.random.rand(1,N[1])
y = np.vstack((np.cos(theta)*r,np.sin(theta)*r))

Shortcut for displaying point clouds.

In [6]:
plotp = lambda x,col: plt.scatter(x[0,:], x[1,:], s=200, edgecolors="k", c=col, linewidths=2)

Display of the two clouds.

In [7]:
plt.figure(figsize=(10,10))

plotp(x, 'b')
plotp(y, 'r')

plt.axis("off")
plt.xlim(np.min(y[0,:])-.1,np.max(y[0,:])+.1)
plt.ylim(np.min(y[1,:])-.1,np.max(y[1,:])+.1)

plt.show()

Cost matrix $C_{i,j} = \norm{x_i-y_j}^2$.

In [8]:
x2 = np.sum(x**2,0)
y2 = np.sum(y**2,0)
C = np.tile(y2,(N[0],1)) + np.tile(x2[:,np.newaxis],(1,N[1])) - 2*np.dot(np.transpose(x),y)

Target histograms, here uniform histograms.

In [9]:
p = np.ones(N[0])/N[0]
q = np.ones(N[1])/N[1]

Regularization strength $\ga$.

In [10]:
gamma = .01;

Gibbs Kernel.

In [11]:
xi = np.exp(-C/gamma)

Initialization of $b_0=\ones_{N_2}$ ($a_0$ does not need to be initialized).

In [12]:
b = np.ones(N[1])

One sinkhorn iterations.

In [13]:
a = p/(np.dot(xi,b))
b = q /(np.dot(np.transpose(xi),a))

Exercise 1

Implement Sinkhorn algorithm. Display the evolution of the constraints satisfaction errors $ \norm{ \pi \ones - p }, \norm{ \pi^T \ones - q } $ (you need to think about how to compute these residuals from $(a,b)$ alone). isplay the violation of constraint error in log-plot.

In [14]:
run -i nt_solutions/optimaltransp_5_entropic/exo1
In [15]:
# Insert your code here.

Compute the final matrix.

In [16]:
Pi = np.dot(np.dot(np.diag(a),xi),np.diag(b))

Display it.

In [17]:
#plt.figure(figsize=(5,5))
plt.imshow(Pi);

Exercise 2

Display the regularized transport solution for various values of $\gamma$. For a too small value of $\gamma$, what do you observe ?

In [18]:
run -i nt_solutions/optimaltransp_5_entropic/exo2
In [19]:
# Insert your code here.

Compute the obtained optimal $\pi$.

In [20]:
Pi = np.dot(np.dot(np.diag(a),xi),np.diag(b))

Keep only the highest entries of the coupling matrix, and use them to draw a map between the two clouds. First we draw "strong" connexions, i.e. linkds $(i,j)$ corresponding to large values of $\pi_{i,j}$. We then draw weaker connexions.

In [21]:
plt.figure(figsize=(10,10))

plotp(x, 'b')
plotp(y, 'r')

A = Pi * (Pi > np.min(1./np.asarray(N))*.7)
i,j = np.where(A != 0)
plt.plot([x[0,i],y[0,j]],[x[1,i],y[1,j]],'k',lw = 2)

A = Pi * (Pi > np.min(1./np.asarray(N))*.3)
i,j = np.where(A != 0)
plt.plot([x[0,i],y[0,j]],[x[1,i],y[1,j]],'k:',lw = 1)

plt.axis("off")
plt.xlim(np.min(y[0,:])-.1,np.max(y[0,:])+.1)
plt.ylim(np.min(y[1,:])-.1,np.max(y[1,:])+.1)

plt.show()

Transport Between Histograms

We now consider a different setup, where the histogram values $p,q$ are not uniform, but the measures are defined on a uniform grid $x_i=y_i=i/N$. They are thue often refered to as "histograms".

Size $N$ of the histograms.

In [22]:
N = 200

We use here a 1-D square Euclidean metric.

In [23]:
t = np.arange(0,N)/N

Define the histogram $p,q$ as translated Gaussians.

In [24]:
Gaussian = lambda t0,sigma: np.exp(-(t-t0)**2/(2*sigma**2))
normalize = lambda p: p/np.sum(p)

sigma = .06;
p = Gaussian(.25,sigma)
q = Gaussian(.8,sigma)

Add some minimal mass and normalize.

In [25]:
vmin = .02;
p = normalize( p+np.max(p)*vmin)
q = normalize( q+np.max(q)*vmin)

Display the histograms.

In [26]:
plt.figure(figsize = (10,7))

plt.subplot(2, 1, 1)
plt.bar(t, p, width = 1/len(t), color = "darkblue")
plt.subplot(2, 1, 2)
plt.bar(t, q, width = 1/len(t), color = "darkblue")

plt.show()

Regularization strength $\ga$.

In [27]:
gamma = (.03)**2

The Gibbs kernel is a Gaussian convolution, $$ \xi_{i,j} = e^{ -(i/N-j/N)^2/\gamma }. $$

In [28]:
[Y,X] = np.meshgrid(t,t)
xi = np.exp(-(X-Y)**2/gamma)

Initialization of $b_0=\ones_{N}$.

In [29]:
b = np.ones(N)

One sinkhorn iteration.

In [30]:
a = p/(np.dot(xi,b))
b = q /(np.dot(np.transpose(xi),a))

Exercise 3

Implement Sinkhorn algorithm. Display the evolution of the constraints satisfaction errors $ \norm{ \pi \ones - p }, \norm{ \pi^T \ones - q } $. You need to think how to compute it from $(a,b)$. Display the violation of constraint error in log-plot.

In [31]:
run -i nt_solutions/optimaltransp_5_entropic/exo3
In [32]:
# Insert your code here.

Display the coupling. Use a log domain plot to better vizualize it.

In [33]:
Pi = np.dot(np.dot(np.diag(a),xi),np.diag(b))
plt.figure(figsize=(5,5))
plt.imshow(np.log(Pi+1e-5))
plt.axis('off');

One can compute an approximation of the transport plan between the two measure by computing the so-called barycentric projection map $$ t_i \in [0,1] \longmapsto s_j \eqdef \frac{\sum_{j} \pi_{i,j} t_j }{ \sum_{j} \pi_{i,j} } = \frac{ [a \odot \xi(b \odot t)]_j }{ p_i }. $$ where $\odot$ and $\frac{\cdot}{\cdot}$ are the enry-wise multiplication and division.

This computation can thus be done using only multiplication with the kernel $\xi$.

In [34]:
s = np.dot(xi,b*t)*a/p

Display the transport map, super-imposed over the coupling.

In [35]:
plt.figure(figsize=(5,5))

plt.imshow(np.log(Pi+1e-5))
plt.plot(s*N,t*N, 'r', linewidth=3)
plt.xlim(0,N)
plt.ylim(N,0)
plt.show()
plt.axis('off');

Exercise 3

Try different regularization strength $\gamma$.

Wasserstein Barycenters

Instead of computing transport, we now turn to the problem of computing barycenter of measures. A barycenter $q$ solves $$ \umin{q} \sum_{k=1}^K W_\ga(p_k,q) $$ where $\la_k$ are positive weights with $\sum_k \la_k=1$. This follows the definition of barycenters proposed in AguehCarlier.

With of the histograms.

In [36]:
N = 70

You need to install imageio, for instance using

conda install -c conda-forge imageio

If you need to rescale the image size, you can use

skimage.transform.resize

Load input histograms $ (p_k)_{k=1}^K $.

In [37]:
import imageio
rescale = lambda x: (x-x.min())/(x.max()-x.min())
names = ['disk','twodisks','letter-x','letter-z']
vmin = .01
P = np.zeros([N,N,len(names)])
for i in range(len(names)):
    p = imageio.imread("nt_toolbox/data/" + names[i] + ".bmp") # ,N) 
    p = normalize(rescale(p)+vmin)
    P[:,:,i] = p
K = len(names)

Display the input histograms.

In [38]:
plt.figure(figsize=(5,5))
for i in range(K):
    plt.subplot(2,2,i+1)
    plt.imshow(P[:,:,i])
    plt.axis('off');

In this specific case, the kernel $\xi$ associated with the squared Euclidean norm is a convolution with a Gaussian filter $$ \xi_{i,j} = e^{ -\norm{i/N-j/N}^2/\gamma } $$ where here $(i,j)$ are 2-D indexes.

The multiplication against the kernel $\xi(a_\ell)$ can now be computed efficiently, using fast convolution methods. This crucial points was exploited and generalized in SolomonEtAl to design fast optimal transport algorithm.

Regularization strength $\ga$.

In [39]:
gamma = (.04)**2

Define the $\xi$ kernel. We use here the fact that the convolution is separable to implement it using only 1-D convolution, which further speeds up computations.

In [40]:
t = np.linspace(0,1,N)
[Y,X] = np.meshgrid(t,t)
xi1 = np.exp(-(X-Y)**2/gamma)
xi = lambda x: np.dot(np.dot(xi1,x),xi1)

Display the application of the $\xi$ kernel on one of the input histogram.

In [41]:
plt.figure(figsize=(10,5))
plt.subplot(1,2,1)
plt.imshow(P[:,:,0])
plt.axis('off');
plt.subplot(1,2,2)
plt.imshow(xi(P[:,:,0]))
plt.axis('off');

Weights for isobarycenter.

In [42]:
lambd = np.ones(K)/K

It is shown in BenamouEtAl that the problem of Barycenter computation boilds down to optimizing over couplings $(\pi_k)_k$, and that this can be achieved using iterative Bregman projection that defines iterates $(\pi_{k,\ell})_k$. These iterates can be written using diagonal scalings $ \pi_{k,\ell} \eqdef \diag(a_{k,\ell}) \xi \diag(b_{k,\ell}). $

Initialize the scaling factors.

In [43]:
b = np.ones([N,N,K])
a = np.copy(b)

The first step of the Bregman projection method corresponds to the projection on the fixed marginals constraints $\pi_k \ones=p_k$. This is achieved by updating $$ \forall k=1,\ldots,K, \quad a_{k,\ell+1} = \frac{p_k}{ \xi( b_{k,\ell} ) }. $$

In [44]:
for k in range(K):
    a[:,:,k] = P[:,:,k]/xi(b[:,:,k])

The second step of the Bregman projection method corresponds to the projection on the equal marginals constraints $\forall k, \pi_k^T \ones=q$. This is achieved by first computing the target barycenter using a geometric means $$ \log(q_\ell) \eqdef \sum_k \lambda_k \log( b_{k,\ell} \odot \xi( a_{k,\ell} ) ). $$

In [45]:
q = np.zeros(N)

for k in range(K):
    q = q + lambd[k] * np.log(np.maximum(1e-19*np.ones(len(b[:,:,k])), b[:,:,k]*xi(a[:,:,k])))

q = np.exp(q)

And then one can update the other maginals to be equal to this barycenter at step $\ell$. $$ \forall k=1,\ldots,K, \quad b_{k,\ell+1} \eqdef \frac{q_\ell}{ \xi(a_{k,\ell+1}) }. $$

In [46]:
for k in range(K):
    b[:,:,k] = q/xi(a[:,:,k])

Exercise 4

Implement the iterative algorithm to compute the iso-barycenter of the measures. Plot the decay of the error $ \sum_k \norm{\pi_k \ones - p_k} $.

In [47]:
run -i nt_solutions/optimaltransp_5_entropic/exo4
In [48]:
# Insert your code here.

Display the barycenter.

In [49]:
plt.imshow(q)
plt.axis('off');

Exercise 5

Compute barycenters for varying weights $\la$ corresponding to a bilinear interpolation inside a square.

In [50]:
run -i nt_solutions/optimaltransp_5_entropic/exo5
In [51]:
# Insert your code here.

Bibliography

  • [Villani] C. Villani, (2009). Optimal transport: old and new, volume 338. Springer Verlag.
  • [Cuturi] M. Cuturi, (2013). Sinkhorn distances: Lightspeed computation of optimal transport. In Burges, C. J. C., Bottou, L., Ghahramani, Z., and Weinberger, K. Q., editors, Proc. NIPS, pages 2292-2300.
  • [AguehCarlier] M. Agueh, and G Carlier, (2011). Barycenters in the Wasserstein space. SIAM J. on Mathematical Analysis, 43(2):904-924.
  • [CuturiDoucet] M. Cuturi and A. Doucet (2014). Fast computation of wasserstein barycenters. In Proc. ICML.
  • [BauschkeLewis] H. H. Bauschke and A. S. Lewis. Dykstra's algorithm with Bregman projections: a convergence proof. Optimization, 48(4):409-427, 2000.
  • [Sinkhorn] R. Sinkhorn. A relationship between arbitrary positive matrices and doubly stochastic matrices. Ann. Math. Statist., 35:876-879, 1964.
  • [SolomonEtAl] J. Solomon, F. de Goes, G. Peyr , M. Cuturi, A. Butscher, A. Nguyen, T. Du, and L. Guibas. Convolutional Wasserstein distances: Efficient optimal transportation on geometric domains. Transaction on Graphics, Proc. SIGGRAPH, 2015.
  • [BenamouEtAl] J-D. Benamou, G. Carlier, M. Cuturi, L. Nenna, G. Peyr . Iterative Bregman Projections for Regularized Transportation Problems. SIAM Journal on Scientific Computing, 37(2), pp. A1111-A1138, 2015.