big update tests

Author: rflamary

test/test_bregman.py

@@ -1078,10 +1078,10 @@ def test_lazy_empirical_sinkhorn(nx):
     sinkhorn_sqe = nx.to_numpy(ot.sinkhorn(ab, bb, M_nx, 1))
 
     f, g, log_es = ot.bregman.empirical_sinkhorn(
-        X_sb, X_tb, 0.1, numIterMax=numIterMax, isLazy=True, batchSize=1, log=True)
+        X_sb, X_tb, 1, numIterMax=numIterMax, isLazy=True, batchSize=5, log=True)
     f, g = nx.to_numpy(f), nx.to_numpy(g)
-    G_log = np.exp(f[:, None] + g[None, :] - M / 0.1)
-    sinkhorn_log, log_s = ot.sinkhorn(ab, bb, M_nx, 0.1, log=True)
+    G_log = np.exp(f[:, None] + g[None, :] - M / 1)
+    sinkhorn_log, log_s = ot.sinkhorn(ab, bb, M_nx, 1, log=True)
     sinkhorn_log = nx.to_numpy(sinkhorn_log)
 
     f, g = ot.bregman.empirical_sinkhorn(
@@ -1091,10 +1091,14 @@ def test_lazy_empirical_sinkhorn(nx):
     sinkhorn_m = nx.to_numpy(ot.sinkhorn(ab, bb, M_mb, 1))
 
     loss_emp_sinkhorn, log = ot.bregman.empirical_sinkhorn2(
-        X_sb, X_tb, 1, numIterMax=numIterMax, isLazy=True, batchSize=1, log=True)
+        X_sb, X_tb, 1, numIterMax=numIterMax, isLazy=True, batchSize=5, log=True)
+    G_lazy = nx.to_numpy(log['lazy_plan'][:])
     loss_emp_sinkhorn = nx.to_numpy(loss_emp_sinkhorn)
     loss_sinkhorn = nx.to_numpy(ot.sinkhorn2(ab, bb, M_nx, 1))
 
+    loss_emp_sinkhorn = ot.bregman.empirical_sinkhorn2(
+        X_sb, X_tb, 1, numIterMax=numIterMax, isLazy=True, batchSize=1, log=False)
+
     # check constraints
     np.testing.assert_allclose(
         sinkhorn_sqe.sum(1), G_sqe.sum(1), atol=1e-05)  # metric sqeuclidian
@@ -1109,6 +1113,7 @@ def test_lazy_empirical_sinkhorn(nx):
     np.testing.assert_allclose(
         sinkhorn_m.sum(0), G_m.sum(0), atol=1e-05)  # metric euclidian
     np.testing.assert_allclose(loss_emp_sinkhorn, loss_sinkhorn, atol=1e-05)
+    np.testing.assert_allclose(G_log, G_lazy, atol=1e-05)
 
 
 def test_empirical_sinkhorn_divergence(nx):

test/test_solvers.py

@@ -25,12 +25,24 @@
 
 lst_method_params_solve_sample = [
     {'method': '1d'},
+    {'method': '1d', 'metric': 'euclidean'},
     {'method': 'gaussian'},
     {'method': 'gaussian', 'reg': 1},
     {'method': 'factored', 'rank': 10},
 ]
+
+lst_parameters_solve_sample_NotImplemented = [
+    {'method': '1d', 'metric': 'any other one'},  # fail 1d on weird metrics
+    {'method': 'gaussian', 'metric': 'euclidean'},  # fail gaussian on metric not euclidean
+    {'method': 'factored', 'metric': 'euclidean'},  # fail factored on metric not euclidean
+    {'lazy': True},  # fail lazy for non regularized
+    {'lazy': True, 'unbalanced': 1},  # fail lazy for non regularized unbalanced
+    {'lazy': True, 'reg': 1, 'unbalanced': 1},  # fail lazy for unbalanced and regularized
+]
+
 # set readable ids for each param
 lst_method_params_solve_sample = [pytest.param(param, id=str(param)) for param in lst_method_params_solve_sample]
+lst_parameters_solve_sample_NotImplemented = [pytest.param(param, id=str(param)) for param in lst_parameters_solve_sample_NotImplemented]
 
 
 def assert_allclose_sol(sol1, sol2):
@@ -268,7 +280,7 @@ def test_solve_gromov_not_implemented(nx):
 
 def test_solve_sample(nx):
     # test solve_sample when is_Lazy = False
-    n = 100
+    n = 20
     X_s = np.reshape(1.0 * np.arange(n), (n, 1))
     X_t = np.reshape(1.0 * np.arange(0, n), (n, 1))
 
@@ -310,6 +322,32 @@ def test_solve_sample(nx):
         sol0 = ot.solve_sample(X_s, X_t, reg=1, reg_type='cryptic divergence')
 
 
+def test_solve_sample_lazy(nx):
+    # test solve_sample when is_Lazy = False
+    n = 20
+    X_s = np.reshape(1.0 * np.arange(n), (n, 1))
+    X_t = np.reshape(1.0 * np.arange(0, n), (n, 1))
+
+    a = ot.utils.unif(X_s.shape[0])
+    b = ot.utils.unif(X_t.shape[0])
+
+    X_s, X_t, a, b = nx.from_numpy(X_s, X_t, a, b)
+
+    M = ot.dist(X_s, X_t)
+
+    # solve with ot.solve
+    sol00 = ot.solve(M, a, b, reg=1)
+
+    sol0 = ot.solve_sample(X_s, X_t, a, b, reg=1)
+
+    # solve signe weights
+    sol = ot.solve_sample(X_s, X_t, a, b, reg=1, lazy=True)
+
+    assert_allclose_sol(sol0, sol00)
+
+    np.testing.assert_allclose(sol0.plan, sol.lazy_plan[:], rtol=1e-5, atol=1e-5)
+
+
 @pytest.mark.parametrize("method_params", lst_method_params_solve_sample)
 def test_solve_sample_methods(nx, method_params):
 
@@ -336,41 +374,20 @@ def test_solve_sample_methods(nx, method_params):
         np.testing.assert_allclose(sol2.value, 0)
 
 
-# def test_lazy_solve_sample(nx):
-#     # test solve_sample when is_Lazy = True
-#     n = 100
-#     X_s = np.reshape(1.0 * np.arange(n), (n, 1))
-#     X_t = np.reshape(1.0 * np.arange(0, n), (n, 1))
-
-#     a = ot.utils.unif(X_s.shape[0])
-#     b = ot.utils.unif(X_t.shape[0])
-
-#     # solve unif weights
-#     sol0 = ot.solve_sample(X_s, X_t, reg=0.1, lazy=True)  # reg != 0 or None since no implementation yet for is_Lazy=True
+@pytest.mark.parametrize("method_params", lst_parameters_solve_sample_NotImplemented)
+def test_solve_sample_NotImplemented(nx, method_params):
 
-#     # solve signe weights
-#     sol = ot.solve_sample(X_s, X_t, a, b, reg=0.1, lazy=True)
-
-#     # check some attributes
-#     sol.potentials
-#     sol.lazy_plan
-
-#     assert_allclose_sol(sol0, sol)
-
-#     # solve in backend
-#     X_sb, X_tb, ab, bb = nx.from_numpy(X_s, X_t, a, b)
-#     solb = ot.solve_sample(X_sb, X_tb, ab, bb, reg=0.1, lazy=True)
-
-#     assert_allclose_sol(sol, solb)
+    n_samples_s = 20
+    n_samples_t = 7
+    n_features = 2
+    rng = np.random.RandomState(0)
 
-#     # test not implemented reg==0 (or None) + balanced and check raise
-#     with pytest.raises(NotImplementedError):
-#         sol0 = ot.solve_sample(X_s, X_t, lazy=True)  # reg == 0 (or None) + unbalanced= None are default
+    x = rng.randn(n_samples_s, n_features)
+    y = rng.randn(n_samples_t, n_features)
+    a = ot.utils.unif(n_samples_s)
+    b = ot.utils.unif(n_samples_t)
 
-#     # test not implemented reg==0 (or None) + unbalanced_type and check raise
-#     with pytest.raises(NotImplementedError):
-#         sol0 = ot.solve_sample(X_s, X_t, unbalanced_type="kl", lazy=True)  # reg == 0 (or None) is default
+    xb, yb, ab, bb = nx.from_numpy(x, y, a, b)
 
-#     # test not implemented reg != 0 + unbalanced_type and check raise
-#     with pytest.raises(NotImplementedError):
-#         sol0 = ot.solve_sample(X_s, X_t, reg=0.1, unbalanced_type="kl", lazy=True)
+    with pytest.raises(NotImplementedError):
+        ot.solve_sample(xb, yb, ab, bb, **method_params)

test/test_utils.py

@@ -318,6 +318,9 @@ def test_cost_normalization(nx):
     M1 = nx.to_numpy(M)
     np.testing.assert_allclose(M1.max(), np.log(1 + np.log(1 + C)).max())
 
+    with pytest.raises(ValueError):
+        ot.utils.cost_normalization(C1, 'error')
+
 
 def test_check_params():
 
@@ -328,6 +331,16 @@ def test_check_params():
     assert res0 is False
 
 
+def test_check_random_state_error():
+    with pytest.raises(ValueError):
+        ot.utils.check_random_state('error')
+
+
+def test_get_parameter_pairs_error():
+    with pytest.raises(ValueError):
+        ot.utils.get_parameter_pairs((1, 2, 3))  # not pair ;)
+
+
 def test_deprecated_func():
 
     @ot.utils.deprecated('deprecated text for fun')
@@ -408,7 +421,8 @@ def test_OTResult():
                       'status',
                       'value',
                       'value_linear',
-                      'value_quad']
+                      'value_quad',
+                      'log']
     for at in lst_attributes:
         print(at)
         with pytest.raises(NotImplementedError):