def test_warnings():
n = 100 # nb bins
m = 100 # nb bins
mean1 = 30
mean2 = 50
# bin positions
x = np.arange(n, dtype=np.float64)
y = np.arange(m, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=mean1, s=5) # m= mean, s= std
b = gauss(m, m=mean2, s=10)
# loss matrix
M = ot.dist(x.reshape((-1, 1)), y.reshape((-1, 1)))**(1. / 2)
print('Computing {} EMD '.format(1))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
print('Computing {} EMD '.format(1))
ot.emd(a, b, M, numItermax=1)
assert "numItermax" in str(w[-1].message)
def test_emd2_multi():
from ot.datasets import get_1D_gauss as gauss
n = 1000 # nb bins
# bin positions
x = np.arange(n, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=20, s=5) # m= mean, s= std
ls = np.arange(20, 1000, 20)
nb = len(ls)
b = np.zeros((n, nb))
for i in range(nb):
b[:, i] = gauss(n, m=ls[i], s=10)
# loss matrix
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)))
# M/=M.max()
print('Computing {} EMD '.format(nb))
# emd loss 1 proc
ot.tic()
emd1 = ot.emd2(a, b, M, 1)
ot.toc('1 proc : {} s')
# emd loss multipro proc
ot.tic()
emdn = ot.emd2(a, b, M)
ot.toc('multi proc : {} s')
np.testing.assert_allclose(emd1, emdn)
def test_emd2_multi():
n = 500 # nb bins
# bin positions
x = np.arange(n, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=20, s=5) # m= mean, s= std
ls = np.arange(20, 500, 20)
nb = len(ls)
b = np.zeros((n, nb))
for i in range(nb):
b[:, i] = gauss(n, m=ls[i], s=10)
# loss matrix
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)))
# M/=M.max()
print('Computing {} EMD '.format(nb))
# emd loss 1 proc
ot.tic()
emd1 = ot.emd2(a, b, M, 1)
ot.toc('1 proc : {} s')
# emd loss multipro proc
ot.tic()
emdn = ot.emd2(a, b, M)
ot.toc('multi proc : {} s')
ot.tic()
emdn2 = ot.emd2(a, b, M, dense=False)
ot.toc('multi proc : {} s')
np.testing.assert_allclose(emd1, emdn)
np.testing.assert_allclose(emd1, emdn2, rtol=1e-6)
# emd loss multipro proc with log
ot.tic()
emdn = ot.emd2(a, b, M, log=True, return_matrix=True)
ot.toc('multi proc : {} s')
for i in range(len(emdn)):
emd = emdn[i]
log = emd[1]
cost = emd[0]
check_duality_gap(a, b[:, i], M, log['G'], log['u'], log['v'], cost)
emdn[i] = cost
emdn = np.array(emdn)
np.testing.assert_allclose(emd1, emdn)
def test_emd2_multi():
n = 1000 # nb bins
# bin positions
x = np.arange(n, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=20, s=5) # m= mean, s= std
ls = np.arange(20, 1000, 20)
nb = len(ls)
b = np.zeros((n, nb))
for i in range(nb):
b[:, i] = gauss(n, m=ls[i], s=10)
# loss matrix
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)))
# M/=M.max()
print('Computing {} EMD '.format(nb))
# emd loss 1 proc
ot.tic()
emd1 = ot.emd2(a, b, M, 1)
ot.toc('1 proc : {} s')
# emd loss multipro proc
ot.tic()
emdn = ot.emd2(a, b, M)
ot.toc('multi proc : {} s')
np.testing.assert_allclose(emd1, emdn)
# emd loss multipro proc with log
ot.tic()
emdn = ot.emd2(a, b, M, log=True, return_matrix=True)
ot.toc('multi proc : {} s')
for i in range(len(emdn)):
emd = emdn[i]
log = emd[1]
cost = emd[0]
check_duality_gap(a, b[:, i], M, log['G'], log['u'], log['v'], cost)
emdn[i] = cost
emdn = np.array(emdn)
np.testing.assert_allclose(emd1, emdn)
def test_dual_variables():
n = 500 # nb bins
m = 600 # nb bins
mean1 = 300
mean2 = 400
# bin positions
x = np.arange(n, dtype=np.float64)
y = np.arange(m, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=mean1, s=5) # m= mean, s= std
b = gauss(m, m=mean2, s=10)
# loss matrix
M = ot.dist(x.reshape((-1, 1)), y.reshape((-1, 1)))**(1. / 2)
print('Computing {} EMD '.format(1))
# emd loss 1 proc
ot.tic()
G, log = ot.emd(a, b, M, log=True)
ot.toc('1 proc : {} s')
ot.tic()
G2 = ot.emd(b, a, np.ascontiguousarray(M.T))
ot.toc('1 proc : {} s')
cost1 = (G * M).sum()
# Check symmetry
np.testing.assert_array_almost_equal(cost1, (M * G2.T).sum())
# Check with closed-form solution for gaussians
np.testing.assert_almost_equal(cost1, np.abs(mean1 - mean2))
# Check that both cost computations are equivalent
np.testing.assert_almost_equal(cost1, log['cost'])
check_duality_gap(a, b, M, G, log['u'], log['v'], log['cost'])
constraint_violation = log['u'][:, None] + log['v'][None, :] - M
assert constraint_violation.max() < 1e-8
def test_dual_variables():
n = 5000 # nb bins
m = 6000 # nb bins
mean1 = 1000
mean2 = 1100
# bin positions
x = np.arange(n, dtype=np.float64)
y = np.arange(m, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=mean1, s=5) # m= mean, s= std
b = gauss(m, m=mean2, s=10)
# loss matrix
M = ot.dist(x.reshape((-1, 1)), y.reshape((-1, 1))) ** (1. / 2)
print('Computing {} EMD '.format(1))
# emd loss 1 proc
ot.tic()
G, log = ot.emd(a, b, M, log=True)
ot.toc('1 proc : {} s')
ot.tic()
G2 = ot.emd(b, a, np.ascontiguousarray(M.T))
ot.toc('1 proc : {} s')
cost1 = (G * M).sum()
# Check symmetry
np.testing.assert_array_almost_equal(cost1, (M * G2.T).sum())
# Check with closed-form solution for gaussians
np.testing.assert_almost_equal(cost1, np.abs(mean1 - mean2))
# Check that both cost computations are equivalent
np.testing.assert_almost_equal(cost1, log['cost'])
check_duality_gap(a, b, M, G, log['u'], log['v'], log['cost'])
def test_warnings():
n = 100 # nb bins
m = 100 # nb bins
mean1 = 30
mean2 = 50
# bin positions
x = np.arange(n, dtype=np.float64)
y = np.arange(m, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=mean1, s=5) # m= mean, s= std
b = gauss(m, m=mean2, s=10)
# loss matrix
M = ot.dist(x.reshape((-1, 1)), y.reshape((-1, 1))) ** (1. / 2)
print('Computing {} EMD '.format(1))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
print('Computing {} EMD '.format(1))
ot.emd(a, b, M, numItermax=1)
assert "numItermax" in str(w[-1].message)
assert len(w) == 1
a[0] = 100
print('Computing {} EMD '.format(2))
ot.emd(a, b, M)
assert "infeasible" in str(w[-1].message)
assert len(w) == 2
a[0] = -1
print('Computing {} EMD '.format(2))
ot.emd(a, b, M)
assert "infeasible" in str(w[-1].message)
assert len(w) == 3
# Generate data
# -------------
#%% parameters
n = 100 # nb bins
n_target = 50 # nb target distributions
# bin positions
x = np.arange(n, dtype=np.float64)
lst_m = np.linspace(20, 90, n_target)
# Gaussian distributions
a = gauss(n, m=20, s=5) # m= mean, s= std
B = np.zeros((n, n_target))
for i, m in enumerate(lst_m):
B[:, i] = gauss(n, m=m, s=5)
# loss matrix and normalization
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)), 'euclidean')
M /= M.max()
M2 = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)), 'sqeuclidean')
M2 /= M2.max()
##############################################################################
# Plot data
# ---------
from ot.datasets import make_1D_gauss as gauss from ot.bregman import screenkhorn ############################################################################## # Generate data # ------------- #%% parameters n = 100 # nb bins # bin positions x = np.arange(n, dtype=np.float64) # Gaussian distributions a = gauss(n, m=20, s=5) # m= mean, s= std b = gauss(n, m=60, s=10) # loss matrix M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1))) M /= M.max() ############################################################################## # Plot distributions and loss matrix # ---------------------------------- #%% plot the distributions pl.figure(1, figsize=(6.4, 3)) pl.plot(x, a, 'b', label='Source distribution') pl.plot(x, b, 'r', label='Target distribution')
return f
#
n = 100
n_traget = 41
#
x = np.arange(n, dtype=np.float64)
lst_m = np.linspace(20, 80, n_traget)
print(lst_m)
# gaussian distributions
f_kl = alpha_fn(alpha=1)
f_rkl = alpha_fn(alpha=0)
f_gan = alpha_fn(alpha='gan')
a = gauss(n, m=50, s=5)
p = lambda x: a[x]
B = np.zeros((n, n_traget))
kl_d = np.zeros(shape=n_traget)
reverse_kl = np.zeros(shape=n_traget)
gan = np.zeros(shape=n_traget)
for i, m in enumerate(lst_m):
b = gauss(n, m=m, s=5)
B[:, i] = b
#
q = lambda x: b[x]
f_kld = lambda x: q(x) * f_kl(p(x) / q(x))
f_rkld = lambda x: q(x) * f_rkl(p(x) / q(x))
f_gand = lambda x: q(x) * f_gan(p(x) / q(x))
for i_x in range(n):
def update_sd(sd):
a = gauss(n, m=40, s=sd)
b = gauss(n, m=50, s=10)
Gs = ot.sinkhorn(a, b, M, 1e-2)
pl = ot.plot.plot1D_mat(a, b, Gs, 'OT matrix G0')
return pl,
import numpy as np
import matplotlib.pylab as pl
import ot
import ot.plot
from ot.datasets import make_1D_gauss as gauss
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
n = 100 # nb bins
# bin positions
x = np.arange(n, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=20, s=5)
b = gauss(n, m=50, s=10)
# loss matrix
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)))
M /= M.max()
# change SD - sinkhorn
fig = plt.figure(3, figsize=(5, 5))
def update_sd(sd):
a = gauss(n, m=40, s=sd)
b = gauss(n, m=50, s=10)
Gs = ot.sinkhorn(a, b, M, 1e-2)
pl = ot.plot.plot1D_mat(a, b, Gs, 'OT matrix G0')
""" import numpy as np import matplotlib.pylab as pl import ot from ot.datasets import get_1D_gauss as gauss #%% parameters n = 100 # nb bins # bin positions x = np.arange(n, dtype=np.float64) # Gaussian distributions a = gauss(n, m=20, s=20) # m= mean, s= std b = gauss(n, m=60, s=60) # loss matrix M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1))) M /= M.max() #%% plot the distributions pl.figure(1) pl.plot(x, a, 'b', label='Source distribution') pl.plot(x, b, 'r', label='Target distribution') pl.legend() #%% plot distributions and loss matrix
import numpy as np
import pylab as pl
import ot
from ot.datasets import get_1D_gauss as gauss
reload(ot.lp)
#%% parameters
n = 5000 # nb bins
# bin positions
x = np.arange(n, dtype=np.float64)
# Gaussian distributions
a = gauss(n, m=20, s=5) # m= mean, s= std
ls = list(range(20, 1000, 10))
nb = len(ls)
b = np.zeros((n, nb))
for i in range(nb):
b[:, i] = gauss(n, m=ls[i], s=10)
# loss matrix
M = ot.dist(x.reshape((n, 1)), x.reshape((n, 1)))
#M/=M.max()
#%%
print(('Computing {} EMD '.format(nb)))
import numpy as np import matplotlib.pylab as pl import ot from ot.datasets import get_1D_gauss as gauss #%% parameters n=100 # nb bins # bin positions x=np.arange(n,dtype=np.float64) # Gaussian distributions a=gauss(n,m=n*.2,s=5) # m= mean, s= std b=gauss(n,m=n*.6,s=10) # loss matrix M=ot.dist(x.reshape((n,1)),x.reshape((n,1))) M/=M.max() #%% plot the distributions pl.figure(1) pl.plot(x,a,'b',label='Source distribution') pl.plot(x,b,'r',label='Target distribution') pl.legend() #%% plot distributions and loss matrix
