Entropic Regularization of Optimal Transport¶



In [1]:
using PyPlot
using NtToolBox


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 = rand(2,N[1])-.5;


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

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


Shortcut for displaying point clouds.

In [6]:
plotp = (x,col) -> scatter(x[1,:], x[2,:], s=200, edgecolors="k", c=col, linewidths=2);


Display of the two clouds.

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

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

axis("off")
xlim(minimum(y[1,:])-.1,maximum(y[1,:])+.1)
ylim(minimum(y[2,:])-.1,maximum(y[2,:])+.1);


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

In [8]:
x2 = sum(x.^2,1)
y2 = sum(y.^2,1)
C = repeat(y2,outer=(N[1],1)) + repeat(x2',outer=(1,N[2])) - 2*x'*y;


Target histograms, here uniform histograms.

In [9]:
p = ones(N[1])/N[1]
q = ones(N[2])/N[2];


Regularization strength $\ga$.

In [10]:
gamma = .01;


Gibbs Kernel.

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


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

In [12]:
b = ones(N[2]);


One sinkhorn iterations.

In [13]:
a = p./(xi*b)
b = q./(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]:
include("NtSolutions/optimaltransp_5_entropic/exo1.jl");

In [15]:
# Insert your code here.


Compute the final matrix.

In [16]:
Pi = (diagm(a)*xi)*diagm(b);


Display it.

In [17]:
figure(figsize=(5,5))
imageplot(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]:
include("NtSolutions/optimaltransp_5_entropic/exo2.jl");

In [19]:
# Insert your code here.


Compute the obtained optimal $\pi$.

In [20]:
Pi = (diagm(a)*xi)*diagm(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]:
figure(figsize=(10,10))

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

A = Pi .* (Pi .> minimum(1./Array(N))*.7)
i,j = findn(A)
plot([x[1,i],y[1,j]],[x[2,i],y[2,j]],"k",lw = 2)

A = Pi .* (Pi .> minimum(1./Array(N))*.3)
i,j = findn(A)
plot([x[1,i],y[1,j]],[x[2,i],y[2,j]],"k:",lw = 1)

axis("off")
xlim(minimum(y[1,:])-.1,maximum(y[1,:])+.1)
ylim(minimum(y[2,:])-.1,maximum(y[2,:])+.1);


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 = collect(0:N-1)/N;


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

In [24]:
Gaussian = (t0,sigma) -> exp(-(t-t0).^2/(2*sigma.^2))
normalize = p -> p/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+maximum(p)*vmin)
q = normalize( q+maximum(q)*vmin);


Display the histograms.

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

subplot(2, 1, 1)
bar(t, p, width = 1/length(t), color = "darkblue")
subplot(2, 1, 2)
bar(t, q, width = 1/length(t), color = "darkblue");


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 =meshgrid(t,t)
xi = exp(-(X-Y).^2/gamma);


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

In [29]:
b = ones(N);


One sinkhorn iteration.

In [30]:
a = p./(xi*b)
b = q./(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]:
include("NtSolutions/optimaltransp_5_entropic/exo3.jl");

In [32]:
# Insert your code here.


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

In [33]:
Pi = (diagm(a)*xi)*diagm(b);
figure(figsize=(5,5))
imageplot(log(Pi+1e-5))


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 = xi*(b.*t).*a./p;


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

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

imageplot(log(Pi+1e-5))
plot(s*N,t*N, "r", linewidth=3)
xlim(0,N)
ylim(N,0);


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;


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

In [37]:
names = ["disk","twodisks","letter-x","letter-z"]
vmin = .05
P = zeros(N,N,length(names))
for i in 1:length(names)
p = load_image(string("NtToolBox/src/data/" , names[i] , ".png"),N)
p = normalize(rescale(p)+vmin)
P[:,:,i] = p
end

K = length(names);


Display the input histograms.

In [38]:
figure(figsize=(5,5))
for i in 1:K
imageplot(P[:,:,i], "",[2,2,i])
end


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]:
n = 41 # width of the convolution kernel
t = collect(linspace(-n/(2*N),n/(2*N),n))
g = exp(-t.^2/gamma)'
g2 = g*g'
xi = x -> conv2(conv2(x, g)',g)'[Base.div(n,2)+1:Base.div(n,2)+size(x,1),Base.