remove jcpot from laplace

1 files changed, 2 insertions, 179 deletions

diff --git a/ot/da.py b/ot/da.py
index 0fdd3be..474c944 100644
--- a/ot/da.py
+++ b/ot/da.py
@@ -14,7 +14,7 @@ Domain adaptation with optimal transport
 import numpy as np
 import scipy.linalg as linalg
 
-from .bregman import sinkhorn, jcpot_barycenter
+from .bregman import sinkhorn
 from .lp import emd
 from .utils import unif, dist, kernel, cost_normalization, laplacian
 from .utils import check_params, BaseEstimator
@@ -2121,181 +2121,4 @@ class UnbalancedSinkhornTransport(BaseTransport):
                 self.coupling_ = returned_
                 self.log_ = dict()
 
-        return self
-
-
-class JCPOTTransport(BaseTransport):
-
-    """Domain Adapatation OT method for multi-source target shift based on Wasserstein barycenter algorithm.
-
-    Parameters
-    ----------
-    reg_e : float, optional (default=1)
-        Entropic regularization parameter
-    max_iter : int, float, optional (default=10)
-        The minimum number of iteration before stopping the optimization
-        algorithm if no it has not converged
-    tol : float, optional (default=10e-9)
-        Stop threshold on error (inner sinkhorn solver) (>0)
-    verbose : bool, optional (default=False)
-        Controls the verbosity of the optimization algorithm
-    log : bool, optional (default=False)
-        Controls the logs of the optimization algorithm
-    metric : string, optional (default="sqeuclidean")
-        The ground metric for the Wasserstein problem
-    norm : string, optional (default=None)
-        If given, normalize the ground metric to avoid numerical errors that
-        can occur with large metric values.
-    distribution_estimation : callable, optional (defaults to the uniform)
-        The kind of distribution estimation to employ
-    out_of_sample_map : string, optional (default="ferradans")
-        The kind of out of sample mapping to apply to transport samples
-        from a domain into another one. Currently the only possible option is
-        "ferradans" which uses the method proposed in [6].
-
-    Attributes
-    ----------
-    coupling_ : list of array-like objects, shape K x (n_source_samples, n_target_samples)
-        A set of optimal couplings between each source domain and the target domain
-    proportions_ : array-like, shape (n_classes,)
-        Estimated class proportions in the target domain
-    log_ : dictionary
-        The dictionary of log, empty dic if parameter log is not True
-
-    References
-    ----------
-
-    .. [1] Ievgen Redko, Nicolas Courty, Rémi Flamary, Devis Tuia
-       "Optimal transport for multi-source domain adaptation under target shift",
-       International Conference on Artificial Intelligence and Statistics (AISTATS),
-       vol. 89, p.849-858, 2019.
-
-    """
-
-    def __init__(self, reg_e=.1, max_iter=10,
-                 tol=10e-9, verbose=False, log=False,
-                 metric="sqeuclidean",
-                 out_of_sample_map='ferradans'):
-        self.reg_e = reg_e
-        self.max_iter = max_iter
-        self.tol = tol
-        self.verbose = verbose
-        self.log = log
-        self.metric = metric
-        self.out_of_sample_map = out_of_sample_map
-
-    def fit(self, Xs, ys=None, Xt=None, yt=None):
-        """Building coupling matrices from a list of source and target sets of samples
-        (Xs, ys) and (Xt, yt)
-
-        Parameters
-        ----------
-        Xs : list of K array-like objects, shape K x (nk_source_samples, n_features)
-            A list of the training input samples.
-        ys : list of K array-like objects, shape K x (nk_source_samples,)
-            A list of the class labels
-        Xt : array-like, shape (n_target_samples, n_features)
-            The training input samples.
-        yt : array-like, shape (n_target_samples,)
-            The class labels. If some target samples are unlabeled, fill the
-            yt's elements with -1.
-
-            Warning: Note that, due to this convention -1 cannot be used as a
-            class label
-
-        Returns
-        -------
-        self : object
-            Returns self.
-        """
-
-        # check the necessary inputs parameters are here
-        if check_params(Xs=Xs, Xt=Xt, ys=ys):
-
-            self.xs_ = Xs
-            self.xt_ = Xt
-
-            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)
-
-            # deal with the value of log
-            if self.log:
-                self.coupling_, self.proportions_, self.log_ = returned_
-            else:
-                self.coupling_, self.proportions_ = returned_
-                self.log_ = dict()
-
-        return self
-
-    def transform(self, Xs=None, ys=None, Xt=None, yt=None, batch_size=128):
-        """Transports source samples Xs onto target ones Xt
-
-        Parameters
-        ----------
-        Xs : array-like, shape (n_source_samples, n_features)
-            The training input samples.
-        ys : array-like, shape (n_source_samples,)
-            The class labels
-        Xt : array-like, shape (n_target_samples, n_features)
-            The training input samples.
-        yt : array-like, shape (n_target_samples,)
-            The class labels. If some target samples are unlabeled, fill the
-            yt's elements with -1.
-
-            Warning: Note that, due to this convention -1 cannot be used as a
-            class label
-        batch_size : int, optional (default=128)
-            The batch size for out of sample inverse transform
-        """
-
-        transp_Xs = []
-
-        # check the necessary inputs parameters are here
-        if check_params(Xs=Xs):
-
-            if all([np.allclose(x, y) for x, y in zip(self.xs_, Xs)]):
-
-                # perform standard barycentric mapping for each source domain
-
-                for coupling in self.coupling_:
-                    transp = coupling / np.sum(coupling, 1)[:, None]
-
-                    # set nans to 0
-                    transp[~ np.isfinite(transp)] = 0
-
-                    # compute transported samples
-                    transp_Xs.append(np.dot(transp, self.xt_))
-            else:
-
-                # perform out of sample mapping
-                indices = np.arange(Xs.shape[0])
-                batch_ind = [
-                    indices[i:i + batch_size]
-                    for i in range(0, len(indices), batch_size)]
-
-                transp_Xs = []
-
-                for bi in batch_ind:
-                    transp_Xs_ = []
-
-                    # get the nearest neighbor in the sources domains
-                    xs = np.concatenate(self.xs_, axis=0)
-                    idx = np.argmin(dist(Xs[bi], xs), axis=1)
-
-                    # transport the source samples
-                    for coupling in self.coupling_:
-                        transp = coupling / np.sum(
-                            coupling, 1)[:, None]
-                        transp[~ np.isfinite(transp)] = 0
-                        transp_Xs_.append(np.dot(transp, self.xt_))
-
-                    transp_Xs_ = np.concatenate(transp_Xs_, axis=0)
-
-                    # define the transported points
-                    transp_Xs_ = transp_Xs_[idx, :] + Xs[bi] - xs[idx, :]
-                    transp_Xs.append(transp_Xs_)
-
-                transp_Xs = np.concatenate(transp_Xs, axis=0)
-
-            return transp_Xs
+        return self
\ No newline at end of file