fix soft labels, remove gammas from jcpot

Author: ievred

ot/bregman.py

@@ -1553,8 +1553,6 @@ def jcpot_barycenter(Xs, Ys, Xt, reg, metric='sqeuclidean', numItermax=100,
 
     Returns
     -------
-    gamma : List of K (nsk x nt) ndarrays
-        Optimal transportation matrices for the given parameters for each pair of source and target domains
     h : (C,) ndarray
         proportion estimation in the target domain
     log : dict
@@ -1574,7 +1572,7 @@ def jcpot_barycenter(Xs, Ys, Xt, reg, metric='sqeuclidean', numItermax=100,
 
     # log dictionary
     if log:
-        log = {'niter': 0, 'err': [], 'M': [], 'D1': [], 'D2': []}
+        log = {'niter': 0, 'err': [], 'M': [], 'D1': [], 'D2': [], 'gamma': []}
 
     K = []
     M = []
@@ -1657,9 +1655,10 @@ def jcpot_barycenter(Xs, Ys, Xt, reg, metric='sqeuclidean', numItermax=100,
         log['M'] = M
         log['D1'] = D1
         log['D2'] = D2
-        return K, bary, log
+        log['gamma'] = K
+        return bary, log
     else:
-        return K, bary
+        return bary
 
 
 def empirical_sinkhorn(X_s, X_t, reg, a=None, b=None, metric='sqeuclidean',

ot/da.py

@@ -956,8 +956,8 @@ def transform_labels(self, ys=None):
 
         Returns
         -------
-        transp_ys : array-like, shape (n_target_samples,)
-            Estimated target labels.
+        transp_ys : array-like, shape (n_target_samples, nb_classes)
+            Estimated soft target labels.
 
         References
         ----------
@@ -985,10 +985,10 @@ def transform_labels(self, ys=None):
             for c in classes:
                 D1[int(c), ysTemp == c] = 1
 
-            # compute transported samples
+            # compute propagated labels
             transp_ys = np.dot(D1, transp)
 
-            return np.argmax(transp_ys, axis=0)
+            return transp_ys.T
 
     def inverse_transform(self, Xs=None, ys=None, Xt=None, yt=None,
                           batch_size=128):
@@ -1066,8 +1066,8 @@ def inverse_transform_labels(self, yt=None):
 
         Returns
         -------
-        transp_ys : array-like, shape (n_source_samples,)
-            Estimated source labels.
+        transp_ys : array-like, shape (n_source_samples, nb_classes)
+            Estimated soft source labels.
         """
 
         # check the necessary inputs parameters are here
@@ -1087,10 +1087,10 @@ def inverse_transform_labels(self, yt=None):
             for c in classes:
                 D1[int(c), ytTemp == c] = 1
 
-            # compute transported samples
+            # compute propagated samples
             transp_ys = np.dot(D1, transp.T)
 
-            return np.argmax(transp_ys, axis=0)
+            return transp_ys.T
 
 
 class LinearTransport(BaseTransport):
@@ -2083,13 +2083,15 @@ class label
 
             returned_ = jcpot_barycenter(Xs=Xs, Ys=ys, Xt=Xt, reg=self.reg_e,
                                          metric=self.metric, distrinumItermax=self.max_iter, stopThr=self.tol,
-                                         verbose=self.verbose, log=self.log)
+                                         verbose=self.verbose, log=True)
+
+            self.coupling_ = returned_[1]['gamma']
 
             # deal with the value of log
             if self.log:
-                self.coupling_, self.proportions_, self.log_ = returned_
+                self.proportions_, self.log_ = returned_
             else:
-                self.coupling_, self.proportions_ = returned_
+                self.proportions_ = returned_
                 self.log_ = dict()
 
         return self
@@ -2176,8 +2178,8 @@ def transform_labels(self, ys=None):
 
         Returns
         -------
-        yt : array-like, shape (n_target_samples,)
-            Estimated target labels.
+        yt : array-like, shape (n_target_samples, nb_classes)
+            Estimated soft target labels.
         """
 
         # check the necessary inputs parameters are here
@@ -2203,10 +2205,10 @@ def transform_labels(self, ys=None):
                     for c in classes:
                         D1[int(c), ysTemp == c] = 1
 
-                # compute transported samples
+                # compute propagated labels
                 yt = yt + np.dot(D1, transp) / len(ys)
 
-            return np.argmax(yt, axis=0)
+            return yt.T
 
     def inverse_transform_labels(self, yt=None):
         """Propagate source labels ys to obtain target labels
@@ -2218,8 +2220,8 @@ def inverse_transform_labels(self, yt=None):
 
         Returns
         -------
-        transp_ys : list of K array-like objects, shape K x (nk_source_samples,)
-            A list of estimated source labels
+        transp_ys : list of K array-like objects, shape K x (nk_source_samples, nb_classes)
+            A list of estimated soft source labels
         """
 
         # check the necessary inputs parameters are here
@@ -2241,7 +2243,7 @@ def inverse_transform_labels(self, yt=None):
                 # set nans to 0
                 transp[~ np.isfinite(transp)] = 0
 
-                # compute transported labels
-                transp_ys.append(np.argmax(np.dot(D1, transp.T), axis=0))
+                # compute propagated labels
+                transp_ys.append(np.dot(D1, transp.T).T)
 
             return transp_ys

test/test_da.py

@@ -68,10 +68,12 @@ def test_sinkhorn_lpl1_transport_class():
     # 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)))
 
     # test unsupervised vs semi-supervised mode
     otda_unsup = ot.da.SinkhornLpl1Transport()
@@ -140,10 +142,12 @@ def test_sinkhorn_l1l2_transport_class():
     # 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)
@@ -229,10 +233,12 @@ def test_sinkhorn_transport_class():
     # 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)
@@ -298,10 +304,12 @@ def test_unbalanced_sinkhorn_transport_class():
     # 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)))
 
     Xs_new, _ = make_data_classif('3gauss', ns + 1)
     transp_Xs_new = otda.transform(Xs_new)
@@ -388,10 +396,12 @@ def test_emd_transport_class():
     # 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)
@@ -645,10 +655,12 @@ def test_jcpot_transport_class():
     # 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, y.shape) for x, y in zip(transp_ys, ys)]
+    [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_jcpot_barycenter():