change name of otda object in test script: clf => otda

1 files changed, 130 insertions, 130 deletions

diff --git a/test/test_da.py b/test/test_da.py
index a757d0a..9fc42a3 100644
--- a/test/test_da.py
+++ b/test/test_da.py
@@ -22,56 +22,56 @@ def test_sinkhorn_lpl1_transport_class():
     Xs, ys = get_data_classif('3gauss', ns)
     Xt, yt = get_data_classif('3gauss2', nt)
 
-    clf = ot.da.SinkhornLpl1Transport()
+    otda = ot.da.SinkhornLpl1Transport()
 
     # test its computed
-    clf.fit(Xs=Xs, ys=ys, Xt=Xt)
-    assert hasattr(clf, "cost_")
-    assert hasattr(clf, "coupling_")
+    otda.fit(Xs=Xs, ys=ys, Xt=Xt)
+    assert hasattr(otda, "cost_")
+    assert hasattr(otda, "coupling_")
 
     # test dimensions of coupling
-    assert_equal(clf.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     Xs_new, _ = get_data_classif('3gauss', ns + 1)
-    transp_Xs_new = clf.transform(Xs_new)
+    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 = clf.inverse_transform(Xt=Xt)
+    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 = clf.inverse_transform(Xt=Xt_new)
+    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 = clf.fit_transform(Xs=Xs, ys=ys, Xt=Xt)
+    transp_Xs = otda.fit_transform(Xs=Xs, ys=ys, Xt=Xt)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     # test unsupervised vs semi-supervised mode
-    clf_unsup = ot.da.SinkhornTransport()
-    clf_unsup.fit(Xs=Xs, Xt=Xt)
-    n_unsup = np.sum(clf_unsup.cost_)
+    otda_unsup = ot.da.SinkhornTransport()
+    otda_unsup.fit(Xs=Xs, Xt=Xt)
+    n_unsup = np.sum(otda_unsup.cost_)
 
-    clf_semi = ot.da.SinkhornTransport()
-    clf_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
-    assert_equal(clf_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    n_semisup = np.sum(clf_semi.cost_)
+    otda_semi = ot.da.SinkhornTransport()
+    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"
@@ -79,7 +79,7 @@ def test_sinkhorn_lpl1_transport_class():
     # check that the coupling forbids mass transport between labeled source
     # and labeled target samples
     mass_semi = np.sum(
-        clf_semi.coupling_[clf_semi.cost_ == clf_semi.limit_max])
+        otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
     assert mass_semi == 0, "semisupervised mode not working"
 
 
@@ -93,57 +93,57 @@ def test_sinkhorn_l1l2_transport_class():
     Xs, ys = get_data_classif('3gauss', ns)
     Xt, yt = get_data_classif('3gauss2', nt)
 
-    clf = ot.da.SinkhornL1l2Transport()
+    otda = ot.da.SinkhornL1l2Transport()
 
     # test its computed
-    clf.fit(Xs=Xs, ys=ys, Xt=Xt)
-    assert hasattr(clf, "cost_")
-    assert hasattr(clf, "coupling_")
-    assert hasattr(clf, "log_")
+    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(clf.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     Xs_new, _ = get_data_classif('3gauss', ns + 1)
-    transp_Xs_new = clf.transform(Xs_new)
+    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 = clf.inverse_transform(Xt=Xt)
+    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 = clf.inverse_transform(Xt=Xt_new)
+    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 = clf.fit_transform(Xs=Xs, ys=ys, Xt=Xt)
+    transp_Xs = otda.fit_transform(Xs=Xs, ys=ys, Xt=Xt)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     # test unsupervised vs semi-supervised mode
-    clf_unsup = ot.da.SinkhornTransport()
-    clf_unsup.fit(Xs=Xs, Xt=Xt)
-    n_unsup = np.sum(clf_unsup.cost_)
+    otda_unsup = ot.da.SinkhornTransport()
+    otda_unsup.fit(Xs=Xs, Xt=Xt)
+    n_unsup = np.sum(otda_unsup.cost_)
 
-    clf_semi = ot.da.SinkhornTransport()
-    clf_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
-    assert_equal(clf_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    n_semisup = np.sum(clf_semi.cost_)
+    otda_semi = ot.da.SinkhornTransport()
+    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"
@@ -151,13 +151,13 @@ def test_sinkhorn_l1l2_transport_class():
     # check that the coupling forbids mass transport between labeled source
     # and labeled target samples
     mass_semi = np.sum(
-        clf_semi.coupling_[clf_semi.cost_ == clf_semi.limit_max])
+        otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
     assert mass_semi == 0, "semisupervised mode not working"
 
     # check everything runs well with log=True
-    clf = ot.da.SinkhornL1l2Transport(log=True)
-    clf.fit(Xs=Xs, ys=ys, Xt=Xt)
-    assert len(clf.log_.keys()) != 0
+    otda = ot.da.SinkhornL1l2Transport(log=True)
+    otda.fit(Xs=Xs, ys=ys, Xt=Xt)
+    assert len(otda.log_.keys()) != 0
 
 
 def test_sinkhorn_transport_class():
@@ -170,57 +170,57 @@ def test_sinkhorn_transport_class():
     Xs, ys = get_data_classif('3gauss', ns)
     Xt, yt = get_data_classif('3gauss2', nt)
 
-    clf = ot.da.SinkhornTransport()
+    otda = ot.da.SinkhornTransport()
 
     # test its computed
-    clf.fit(Xs=Xs, Xt=Xt)
-    assert hasattr(clf, "cost_")
-    assert hasattr(clf, "coupling_")
-    assert hasattr(clf, "log_")
+    otda.fit(Xs=Xs, Xt=Xt)
+    assert hasattr(otda, "cost_")
+    assert hasattr(otda, "coupling_")
+    assert hasattr(otda, "log_")
 
     # test dimensions of coupling
-    assert_equal(clf.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     Xs_new, _ = get_data_classif('3gauss', ns + 1)
-    transp_Xs_new = clf.transform(Xs_new)
+    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 = clf.inverse_transform(Xt=Xt)
+    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 = clf.inverse_transform(Xt=Xt_new)
+    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 = clf.fit_transform(Xs=Xs, Xt=Xt)
+    transp_Xs = otda.fit_transform(Xs=Xs, Xt=Xt)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     # test unsupervised vs semi-supervised mode
-    clf_unsup = ot.da.SinkhornTransport()
-    clf_unsup.fit(Xs=Xs, Xt=Xt)
-    n_unsup = np.sum(clf_unsup.cost_)
+    otda_unsup = ot.da.SinkhornTransport()
+    otda_unsup.fit(Xs=Xs, Xt=Xt)
+    n_unsup = np.sum(otda_unsup.cost_)
 
-    clf_semi = ot.da.SinkhornTransport()
-    clf_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
-    assert_equal(clf_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    n_semisup = np.sum(clf_semi.cost_)
+    otda_semi = ot.da.SinkhornTransport()
+    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"
@@ -228,13 +228,13 @@ def test_sinkhorn_transport_class():
     # check that the coupling forbids mass transport between labeled source
     # and labeled target samples
     mass_semi = np.sum(
-        clf_semi.coupling_[clf_semi.cost_ == clf_semi.limit_max])
+        otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
     assert mass_semi == 0, "semisupervised mode not working"
 
     # check everything runs well with log=True
-    clf = ot.da.SinkhornTransport(log=True)
-    clf.fit(Xs=Xs, ys=ys, Xt=Xt)
-    assert len(clf.log_.keys()) != 0
+    otda = ot.da.SinkhornTransport(log=True)
+    otda.fit(Xs=Xs, ys=ys, Xt=Xt)
+    assert len(otda.log_.keys()) != 0
 
 
 def test_emd_transport_class():
@@ -247,56 +247,56 @@ def test_emd_transport_class():
     Xs, ys = get_data_classif('3gauss', ns)
     Xt, yt = get_data_classif('3gauss2', nt)
 
-    clf = ot.da.EMDTransport()
+    otda = ot.da.EMDTransport()
 
     # test its computed
-    clf.fit(Xs=Xs, Xt=Xt)
-    assert hasattr(clf, "cost_")
-    assert hasattr(clf, "coupling_")
+    otda.fit(Xs=Xs, Xt=Xt)
+    assert hasattr(otda, "cost_")
+    assert hasattr(otda, "coupling_")
 
     # test dimensions of coupling
-    assert_equal(clf.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     Xs_new, _ = get_data_classif('3gauss', ns + 1)
-    transp_Xs_new = clf.transform(Xs_new)
+    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 = clf.inverse_transform(Xt=Xt)
+    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 = clf.inverse_transform(Xt=Xt_new)
+    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 = clf.fit_transform(Xs=Xs, Xt=Xt)
+    transp_Xs = otda.fit_transform(Xs=Xs, Xt=Xt)
     assert_equal(transp_Xs.shape, Xs.shape)
 
     # test unsupervised vs semi-supervised mode
-    clf_unsup = ot.da.SinkhornTransport()
-    clf_unsup.fit(Xs=Xs, Xt=Xt)
-    n_unsup = np.sum(clf_unsup.cost_)
+    otda_unsup = ot.da.SinkhornTransport()
+    otda_unsup.fit(Xs=Xs, Xt=Xt)
+    n_unsup = np.sum(otda_unsup.cost_)
 
-    clf_semi = ot.da.SinkhornTransport()
-    clf_semi.fit(Xs=Xs, ys=ys, Xt=Xt, yt=yt)
-    assert_equal(clf_semi.cost_.shape, ((Xs.shape[0], Xt.shape[0])))
-    n_semisup = np.sum(clf_semi.cost_)
+    otda_semi = ot.da.SinkhornTransport()
+    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"
@@ -304,7 +304,7 @@ def test_emd_transport_class():
     # check that the coupling forbids mass transport between labeled source
     # and labeled target samples
     mass_semi = np.sum(
-        clf_semi.coupling_[clf_semi.cost_ == clf_semi.limit_max])
+        otda_semi.coupling_[otda_semi.cost_ == otda_semi.limit_max])
     assert mass_semi == 0, "semisupervised mode not working"
 
 
@@ -324,47 +324,47 @@ def test_mapping_transport_class():
     ##########################################################################
 
     # check computation and dimensions if bias == False
-    clf = ot.da.MappingTransport(kernel="linear", bias=False)
-    clf.fit(Xs=Xs, Xt=Xt)
-    assert hasattr(clf, "coupling_")
-    assert hasattr(clf, "mapping_")
-    assert hasattr(clf, "log_")
+    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(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.mapping_.shape, ((Xs.shape[1], Xt.shape[1])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
-    transp_Xs_new = clf.transform(Xs_new)
+    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
-    clf = ot.da.MappingTransport(kernel="linear", bias=True)
-    clf.fit(Xs=Xs, Xt=Xt)
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.mapping_.shape, ((Xs.shape[1] + 1, Xt.shape[1])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
-    transp_Xs_new = clf.transform(Xs_new)
+    transp_Xs_new = otda.transform(Xs_new)
 
     # check that the oos method is working
     assert_equal(transp_Xs_new.shape, Xs_new.shape)
@@ -374,52 +374,52 @@ def test_mapping_transport_class():
     ##########################################################################
 
     # check computation and dimensions if bias == False
-    clf = ot.da.MappingTransport(kernel="gaussian", bias=False)
-    clf.fit(Xs=Xs, Xt=Xt)
+    otda = ot.da.MappingTransport(kernel="gaussian", bias=False)
+    otda.fit(Xs=Xs, Xt=Xt)
 
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.mapping_.shape, ((Xs.shape[0], Xt.shape[1])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
-    transp_Xs_new = clf.transform(Xs_new)
+    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
-    clf = ot.da.MappingTransport(kernel="gaussian", bias=True)
-    clf.fit(Xs=Xs, Xt=Xt)
-    assert_equal(clf.coupling_.shape, ((Xs.shape[0], Xt.shape[0])))
-    assert_equal(clf.mapping_.shape, ((Xs.shape[0] + 1, Xt.shape[1])))
+    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(clf.coupling_, axis=0), mu_t, rtol=1e-3, atol=1e-3)
-    assert_allclose(np.sum(clf.coupling_, axis=1), mu_s, rtol=1e-3, atol=1e-3)
+    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 = clf.transform(Xs=Xs)
+    transp_Xs = otda.transform(Xs=Xs)
     assert_equal(transp_Xs.shape, Xs.shape)
 
-    transp_Xs_new = clf.transform(Xs_new)
+    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
-    clf = ot.da.MappingTransport(kernel="gaussian", log=True)
-    clf.fit(Xs=Xs, Xt=Xt)
-    assert len(clf.log_.keys()) != 0
+    otda = ot.da.MappingTransport(kernel="gaussian", log=True)
+    otda.fit(Xs=Xs, Xt=Xt)
+    assert len(otda.log_.keys()) != 0
 
 
 def test_otda():