def __init__(self,
xs,
xt,
M,
manifold,
a=None,
b=None,
reg_fidelity=1.,
reg_ot=1e-3,
eps=1e-15,
ot_solver='sinkhorn'):
super(LossModule, self).__init__()
self.M = deepcopy(M).detach_()
self.xs_ = xs
self.xt_ = xt
self.ns_ = len(xs)
self.nt_ = len(xt)
self.manifold = manifold
self.reg_fidelity = reg_fidelity
self.reg_ot = reg_ot
self.eps = eps
self.ot_solver = ot_solver
self.a = torch.FloatTensor(unif(self.ns_)) if a is None else a
self.b = torch.FloatTensor(unif(self.nt_)) if b is None else b
def test_mapping_transport_class(nx, kernel, bias):
"""test_mapping_transport
"""
ns = 20
nt = 30
Xs, ys = make_data_classif('3gauss', ns)
Xt, yt = make_data_classif('3gauss2', nt)
Xs_new, _ = make_data_classif('3gauss', ns + 1)
Xs, Xt, Xs_new = nx.from_numpy(Xs, Xt, Xs_new)
# Mapping tests
bias = bias == "biased"
otda = ot.da.MappingTransport(kernel=kernel, bias=bias)
otda.fit(Xs=Xs, Xt=Xt)
assert hasattr(otda, "coupling_")
assert hasattr(otda, "mapping_")
assert hasattr(otda, "log_")
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
S = Xs.shape[0] if kernel == "gaussian" else Xs.shape[1] # if linear
if bias:
S += 1
assert_equal(otda.mapping_.shape, ((S, Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
nx.to_numpy(nx.sum(otda.coupling_, axis=0)), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
nx.to_numpy(nx.sum(otda.coupling_, axis=1)), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check everything runs well with log=True
otda = ot.da.MappingTransport(kernel=kernel, bias=bias, log=True)
otda.fit(Xs=Xs, Xt=Xt)
assert len(otda.log_.keys()) != 0
def sinkhorn_cost(x,
y,
reg_ot=1.,
nx=None,
ny=None,
ys=None,
yt=None,
n_iter=100,
manifold=None,
normalization='max',
wrapped_function=None,
detach_x=False,
detach_y=True,
is_hyperbolic=False,
match_targets=False):
nx = len(x) if nx is None else nx
ny = len(y) if ny is None else ny
a = torch.FloatTensor(unif(nx)).detach()
b = torch.FloatTensor(unif(ny)).detach()
M = compute_cost(x,
y,
manifold=manifold,
ys=ys,
yt=yt,
match_targets=match_targets,
normalization=normalization,
wrapped_function=wrapped_function,
detach_x=detach_x,
detach_y=detach_y,
is_hyperbolic=is_hyperbolic)
return sinkhorn_loss(a,
b,
M,
epsilon=reg_ot,
n_iter=n_iter,
return_coupling=True)
def test_sinkhorn_l1l2_transport_class():
"""test_sinkhorn_transport
"""
ns = 150
nt = 200
Xs, ys = make_data_classif('3gauss', ns)
Xt, yt = make_data_classif('3gauss2', nt)
otda = ot.da.SinkhornL1l2Transport()
# test its computed
otda.fit(Xs=Xs, ys=ys, Xt=Xt)
assert hasattr(otda, "cost_")
assert hasattr(otda, "coupling_")
assert hasattr(otda, "log_")
# test dimensions of coupling
assert_equal(otda.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
Xs_new, _ = make_data_classif('3gauss', ns + 1)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# test inverse transform
transp_Xt = otda.inverse_transform(Xt=Xt)
assert_equal(transp_Xt.shape, Xt.shape)
# check label propagation
transp_yt = otda.transform_labels(ys)
assert_equal(transp_yt.shape[0], yt.shape[0])
assert_equal(transp_yt.shape[1], len(np.unique(ys)))
# check inverse label propagation
transp_ys = otda.inverse_transform_labels(yt)
assert_equal(transp_ys.shape[0], ys.shape[0])
assert_equal(transp_ys.shape[1], len(np.unique(yt)))
Xt_new, _ = make_data_classif('3gauss2', nt + 1)
transp_Xt_new = otda.inverse_transform(Xt=Xt_new)
# check that the oos method is working
assert_equal(transp_Xt_new.shape, Xt_new.shape)
# test fit_transform
transp_Xs = otda.fit_transform(Xs=Xs, ys=ys, Xt=Xt)
assert_equal(transp_Xs.shape, Xs.shape)
# test unsupervised vs semi-supervised mode
otda_unsup = ot.da.SinkhornL1l2Transport()
otda_unsup.fit(Xs=Xs, ys=ys, Xt=Xt)
n_unsup = np.sum(otda_unsup.cost_)
otda_semi = ot.da.SinkhornL1l2Transport()
otda_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
assert_equal(otda_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
n_semisup = np.sum(otda_semi.cost_)
# check that the cost matrix norms are indeed different
assert n_unsup != n_semisup, "semisupervised mode not working"
# check that the coupling forbids mass transport between labeled source
# and labeled target samples
mass_semi = np.sum(
otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
mass_semi = otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max]
assert_allclose(mass_semi, np.zeros_like(mass_semi), rtol=1e-9, atol=1e-9)
# check everything runs well with log=True
otda = ot.da.SinkhornL1l2Transport(log=True)
otda.fit(Xs=Xs, ys=ys, Xt=Xt)
assert len(otda.log_.keys()) != 0
def test_jcpot_transport_class():
"""test_jcpot_transport
"""
ns1 = 150
ns2 = 150
nt = 200
Xs1, ys1 = make_data_classif('3gauss', ns1)
Xs2, ys2 = make_data_classif('3gauss', ns2)
Xt, yt = make_data_classif('3gauss2', nt)
Xs = [Xs1, Xs2]
ys = [ys1, ys2]
otda = ot.da.JCPOTTransport(reg_e=1,
max_iter=10000,
tol=1e-9,
verbose=True,
log=True)
# test its computed
otda.fit(Xs=Xs, ys=ys, Xt=Xt)
assert hasattr(otda, "coupling_")
assert hasattr(otda, "proportions_")
assert hasattr(otda, "log_")
# test dimensions of coupling
for i, xs in enumerate(Xs):
assert_equal(otda.coupling_[i].shape, ((xs.shape[0], Xt.shape[0])))
# test all margin constraints
mu_t = unif(nt)
for i in range(len(Xs)):
# test margin constraints w.r.t. uniform target weights for each coupling matrix
assert_allclose(np.sum(otda.coupling_[i], axis=0),
mu_t,
rtol=1e-3,
atol=1e-3)
# test margin constraints w.r.t. modified source weights for each source domain
assert_allclose(np.dot(otda.log_['D1'][i],
np.sum(otda.coupling_[i], axis=1)),
otda.proportions_,
rtol=1e-3,
atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
[assert_equal(x.shape, y.shape) for x, y in zip(transp_Xs, Xs)]
Xs_new, _ = make_data_classif('3gauss', ns1 + 1)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check label propagation
transp_yt = otda.transform_labels(ys)
assert_equal(transp_yt.shape[0], yt.shape[0])
assert_equal(transp_yt.shape[1], len(np.unique(ys)))
# check inverse label propagation
transp_ys = otda.inverse_transform_labels(yt)
[assert_equal(x.shape[0], y.shape[0]) for x, y in zip(transp_ys, ys)]
[
assert_equal(x.shape[1], len(np.unique(y)))
for x, y in zip(transp_ys, ys)
]
def test_mapping_transport_class():
"""test_mapping_transport
"""
ns = 60
nt = 120
Xs, ys = make_data_classif('3gauss', ns)
Xt, yt = make_data_classif('3gauss2', nt)
Xs_new, _ = make_data_classif('3gauss', ns + 1)
##########################################################################
# kernel == linear mapping tests
##########################################################################
# check computation and dimensions if bias == False
otda = ot.da.MappingTransport(kernel="linear", bias=False)
otda.fit(Xs=Xs, Xt=Xt)
assert hasattr(otda, "coupling_")
assert hasattr(otda, "mapping_")
assert hasattr(otda, "log_")
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[1], Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check computation and dimensions if bias == True
otda = ot.da.MappingTransport(kernel="linear", bias=True)
otda.fit(Xs=Xs, Xt=Xt)
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[1] + 1, Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
##########################################################################
# kernel == gaussian mapping tests
##########################################################################
# check computation and dimensions if bias == False
otda = ot.da.MappingTransport(kernel="gaussian", bias=False)
otda.fit(Xs=Xs, Xt=Xt)
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[0], Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check computation and dimensions if bias == True
otda = ot.da.MappingTransport(kernel="gaussian", bias=True)
otda.fit(Xs=Xs, Xt=Xt)
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[0] + 1, Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check everything runs well with log=True
otda = ot.da.MappingTransport(kernel="gaussian", log=True)
otda.fit(Xs=Xs, Xt=Xt)
assert len(otda.log_.keys()) != 0
def test_emd_transport_class():
"""test_sinkhorn_transport
"""
ns = 150
nt = 200
Xs, ys = make_data_classif('3gauss', ns)
Xt, yt = make_data_classif('3gauss2', nt)
otda = ot.da.EMDTransport()
# test its computed
otda.fit(Xs=Xs, Xt=Xt)
assert hasattr(otda, "cost_")
assert hasattr(otda, "coupling_")
# test dimensions of coupling
assert_equal(otda.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
Xs_new, _ = make_data_classif('3gauss', ns + 1)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# test inverse transform
transp_Xt = otda.inverse_transform(Xt=Xt)
assert_equal(transp_Xt.shape, Xt.shape)
Xt_new, _ = make_data_classif('3gauss2', nt + 1)
transp_Xt_new = otda.inverse_transform(Xt=Xt_new)
# check that the oos method is working
assert_equal(transp_Xt_new.shape, Xt_new.shape)
# test fit_transform
transp_Xs = otda.fit_transform(Xs=Xs, Xt=Xt)
assert_equal(transp_Xs.shape, Xs.shape)
# test unsupervised vs semi-supervised mode
otda_unsup = ot.da.EMDTransport()
otda_unsup.fit(Xs=Xs, ys=ys, Xt=Xt)
n_unsup = np.sum(otda_unsup.cost_)
otda_semi = ot.da.EMDTransport()
otda_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
assert_equal(otda_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
n_semisup = np.sum(otda_semi.cost_)
# check that the cost matrix norms are indeed different
assert n_unsup != n_semisup, "semisupervised mode not working"
# check that the coupling forbids mass transport between labeled source
# and labeled target samples
mass_semi = np.sum(
otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
mass_semi = otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max]
# we need to use a small tolerance here, otherwise the test breaks
assert_allclose(mass_semi, np.zeros_like(mass_semi),
rtol=1e-2, atol=1e-2)
def test_emd_laplace_class():
"""test_emd_laplace_transport
"""
ns = 150
nt = 200
Xs, ys = make_data_classif('3gauss', ns)
Xt, yt = make_data_classif('3gauss2', nt)
otda = ot.da.EMDLaplaceTransport(reg_lap=0.01,
max_iter=1000,
tol=1e-9,
verbose=False,
log=True)
# test its computed
otda.fit(Xs=Xs, ys=ys, Xt=Xt)
assert hasattr(otda, "coupling_")
assert hasattr(otda, "log_")
# test dimensions of coupling
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
# test all margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
[assert_equal(x.shape, y.shape) for x, y in zip(transp_Xs, Xs)]
Xs_new, _ = make_data_classif('3gauss', ns + 1)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# test inverse transform
transp_Xt = otda.inverse_transform(Xt=Xt)
assert_equal(transp_Xt.shape, Xt.shape)
Xt_new, _ = make_data_classif('3gauss2', nt + 1)
transp_Xt_new = otda.inverse_transform(Xt=Xt_new)
# check that the oos method is working
assert_equal(transp_Xt_new.shape, Xt_new.shape)
# test fit_transform
transp_Xs = otda.fit_transform(Xs=Xs, Xt=Xt)
assert_equal(transp_Xs.shape, Xs.shape)
# check label propagation
transp_yt = otda.transform_labels(ys)
assert_equal(transp_yt.shape[0], yt.shape[0])
assert_equal(transp_yt.shape[1], len(np.unique(ys)))
# check inverse label propagation
transp_ys = otda.inverse_transform_labels(yt)
assert_equal(transp_ys.shape[0], ys.shape[0])
assert_equal(transp_ys.shape[1], len(np.unique(yt)))
def test_sinkhorn_l1l2_transport_class():
"""test_sinkhorn_transport
"""
ns = 150
nt = 200
Xs, ys = get_data_classif('3gauss', ns)
Xt, yt = get_data_classif('3gauss2', nt)
otda = ot.da.SinkhornL1l2Transport()
# test its computed
otda.fit(Xs=Xs, ys=ys, Xt=Xt)
assert hasattr(otda, "cost_")
assert hasattr(otda, "coupling_")
assert hasattr(otda, "log_")
# test dimensions of coupling
assert_equal(otda.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
Xs_new, _ = get_data_classif('3gauss', ns + 1)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# test inverse transform
transp_Xt = otda.inverse_transform(Xt=Xt)
assert_equal(transp_Xt.shape, Xt.shape)
Xt_new, _ = get_data_classif('3gauss2', nt + 1)
transp_Xt_new = otda.inverse_transform(Xt=Xt_new)
# check that the oos method is working
assert_equal(transp_Xt_new.shape, Xt_new.shape)
# test fit_transform
transp_Xs = otda.fit_transform(Xs=Xs, ys=ys, Xt=Xt)
assert_equal(transp_Xs.shape, Xs.shape)
# test unsupervised vs semi-supervised mode
otda_unsup = ot.da.SinkhornL1l2Transport()
otda_unsup.fit(Xs=Xs, ys=ys, Xt=Xt)
n_unsup = np.sum(otda_unsup.cost_)
otda_semi = ot.da.SinkhornL1l2Transport()
otda_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
assert_equal(otda_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
n_semisup = np.sum(otda_semi.cost_)
# check that the cost matrix norms are indeed different
assert n_unsup != n_semisup, "semisupervised mode not working"
# check that the coupling forbids mass transport between labeled source
# and labeled target samples
mass_semi = np.sum(
otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
mass_semi = otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max]
assert_allclose(mass_semi, np.zeros_like(mass_semi),
rtol=1e-9, atol=1e-9)
# check everything runs well with log=True
otda = ot.da.SinkhornL1l2Transport(log=True)
otda.fit(Xs=Xs, ys=ys, Xt=Xt)
assert len(otda.log_.keys()) != 0
def test_mapping_transport_class():
"""test_mapping_transport
"""
ns = 60
nt = 120
Xs, ys = get_data_classif('3gauss', ns)
Xt, yt = get_data_classif('3gauss2', nt)
Xs_new, _ = get_data_classif('3gauss', ns + 1)
##########################################################################
# kernel == linear mapping tests
##########################################################################
# check computation and dimensions if bias == False
otda = ot.da.MappingTransport(kernel="linear", bias=False)
otda.fit(Xs=Xs, Xt=Xt)
assert hasattr(otda, "coupling_")
assert hasattr(otda, "mapping_")
assert hasattr(otda, "log_")
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[1], Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check computation and dimensions if bias == True
otda = ot.da.MappingTransport(kernel="linear", bias=True)
otda.fit(Xs=Xs, Xt=Xt)
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[1] + 1, Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
##########################################################################
# kernel == gaussian mapping tests
##########################################################################
# check computation and dimensions if bias == False
otda = ot.da.MappingTransport(kernel="gaussian", bias=False)
otda.fit(Xs=Xs, Xt=Xt)
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[0], Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check computation and dimensions if bias == True
otda = ot.da.MappingTransport(kernel="gaussian", bias=True)
otda.fit(Xs=Xs, Xt=Xt)
assert_equal(otda.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
assert_equal(otda.mapping_.shape, ((Xs.shape[0] + 1, Xt.shape[1])))
# test margin constraints
mu_s = unif(ns)
mu_t = unif(nt)
assert_allclose(
np.sum(otda.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
assert_allclose(
np.sum(otda.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
# test transform
transp_Xs = otda.transform(Xs=Xs)
assert_equal(transp_Xs.shape, Xs.shape)
transp_Xs_new = otda.transform(Xs_new)
# check that the oos method is working
assert_equal(transp_Xs_new.shape, Xs_new.shape)
# check everything runs well with log=True
otda = ot.da.MappingTransport(kernel="gaussian", log=True)
otda.fit(Xs=Xs, Xt=Xt)
assert len(otda.log_.keys()) != 0
def compute_transport(Xs,
Xt,
ys=None,
yt=None,
manifold=None,
M=None,
reg_ot=1e-2,
is_hyperbolic=True,
normalization='max',
wrapped_function=None,
ot_solver='sinkhorn_knopp',
limit_max=1e15,
detach_x=False,
detach_y=True,
match_targets=False,
verbose=False):
ns, nt = len(Xs), len(Xt)
a_np = unif(ns)
b_np = unif(nt)
if M is None:
M_0 = compute_cost(Xs=Xs,
Xt=Xt,
ys=ys,
yt=yt,
manifold=manifold,
is_hyperbolic=is_hyperbolic,
normalization=normalization,
wrapped_function=wrapped_function,
match_targets=match_targets,
detach_x=detach_x,
detach_y=detach_y)
M_np = M_0.data.numpy()
else:
M_0 = M.detach()
M_0 = cost_normalization(M_0, normalization)
M_np = M_0.data.numpy()
if ((ys is not None) and (yt is not None)) and match_targets:
ys_ = ys.data.numpy()
yt_ = yt.data.numpy()
classes = [c for c in np.unique(ys_) if c != -1]
# assumes labeled source samples occupy the first rows
# and labeled target samples occupy the first columns
for c in classes:
idx_s = np.where((ys_ != c) & (ys_ != -1))
idx_t = np.where(yt_ == c)
# all the coefficients corresponding to a source sample
# and a target sample :
# with different labels get a infinite
for j in idx_t[0]:
M_np[idx_s[0], j] = limit_max
if verbose:
print("Computing initial coupling...")
if reg_ot == 0:
G_np = emd(a_np, b_np, M_np)
else:
if ot_solver == 'greenkhorn':
G_np = greenkhorn(a_np, b_np, M_np, reg=reg_ot)
elif ot_solver == 'sinkhorn':
G_np = sinkhorn_stabilized(a_np, b_np, M_np, reg=reg_ot)
elif ot_solver == 'sinkhorn_knopp':
G_np = sinkhorn_knopp(a_np, b_np, M_np, reg=reg_ot)
else:
raise ValueError
if verbose:
print("Coupling done")
a = torch.FloatTensor(a_np).detach_()
b = torch.FloatTensor(b_np).detach_()
G = torch.FloatTensor(G_np).detach_()
M = torch.FloatTensor(M_np).detach_()
return a, b, M, G