Merge pull request #75 from antoinedemathelin/master

Add TCA

Author: antoinedemathelin

adapt/base.py

@@ -476,9 +476,15 @@ def fit(self, X, y, Xt=None, yt=None, domains=None, **fit_params):
         if hasattr(self, "fit_weights"):
             if self.verbose:
                 print("Fit weights...")
-            self.weights_ = self.fit_weights(Xs=X, Xt=Xt,
-                                             ys=y, yt=yt,
-                                             domains=domains)
+            out = self.fit_weights(Xs=X, Xt=Xt,
+                                   ys=y, yt=yt,
+                                   domains=domains)
+            if isinstance(out, tuple):
+                self.weights_ = out[0]
+                X = out[1]
+                y = out[2]
+            else:
+                self.weights_ = out
             if "sample_weight" in fit_params:
                 fit_params["sample_weight"] *= self.weights_
             else:

adapt/feature_based/__init__.py

@@ -14,6 +14,7 @@
 from ._sa import SA
 from ._fmmd import fMMD
 from ._ccsa import CCSA
+from ._tca import TCA
 
 __all__ = ["FA", "CORAL", "DeepCORAL", "ADDA", "DANN",
-           "MCD", "MDD", "WDGRL", "CDAN", "SA", "fMMD", "CCSA"]
+           "MCD", "MDD", "WDGRL", "CDAN", "SA", "fMMD", "CCSA", "TCA"]

adapt/feature_based/_tca.py

@@ -0,0 +1,169 @@
+"""
+TCA
+"""
+
+import numpy as np
+from sklearn.utils import check_array
+from sklearn.metrics import pairwise
+from sklearn.metrics.pairwise import KERNEL_PARAMS
+from scipy import linalg
+
+from adapt.base import BaseAdaptEstimator, make_insert_doc
+from adapt.utils import set_random_seed
+
+
+@make_insert_doc()
+class TCA(BaseAdaptEstimator):
+    """
+    TCA :  Transfer Component Analysis
+    
+    Parameters
+    ----------
+    n_components : int or float (default=None)
+        Number of components to keep.
+    
+    mu : float (default=0.1)
+        Regularization parameter. The larger
+        ``mu`` is, the less adaptation is performed.
+
+    Attributes
+    ----------
+    estimator_ : object
+        Estimator.
+        
+    Examples
+    --------
+    >>> from sklearn.linear_model import RidgeClassifier
+    >>> from adapt.utils import make_classification_da
+    >>> from adapt.feature_based import TCA
+    >>> Xs, ys, Xt, yt = make_classification_da()
+    >>> model = TCA(RidgeClassifier(), Xt=Xt, n_components=1, mu=0.1, 
+    ...             kernel="rbf", gamma=0.1, verbose=0, random_state=0)
+    >>> model.fit(Xs, ys)
+    >>> model.score(Xt, yt)
+    0.93
+        
+    See also
+    --------
+    CORAL
+    FA
+    
+    References
+    ----------
+    .. [1] `[1] <https://www.cse.ust.hk/~qyang/Docs/2009/TCA.pdf>` S. J. Pan, \
+I. W. Tsang, J. T. Kwok and Q. Yang. "Domain Adaptation via Transfer Component \
+Analysis". In IEEE transactions on neural networks 2010
+    """
+    def __init__(self,
+                 estimator=None,
+                 Xt=None,
+                 n_components=20,
+                 mu=0.1,
+                 kernel="rbf",
+                 copy=True,
+                 verbose=1,
+                 random_state=None,
+                 **params):
+        
+        names = self._get_param_names()
+        kwargs = {k: v for k, v in locals().items() if k in names}
+        kwargs.update(params)
+        super().__init__(**kwargs)
+
+
+    def fit_transform(self, Xs, Xt, **kwargs):
+        """
+        Fit embeddings.
+        
+        Parameters
+        ----------
+        Xs : array
+            Input source data.
+            
+        Xt : array
+            Input target data.
+                        
+        kwargs : key, value argument
+            Not used, present here for adapt consistency.
+            
+        Returns
+        -------
+        Xs_emb : embedded source data
+        """
+        Xs = check_array(Xs)
+        Xt = check_array(Xt)
+        set_random_seed(self.random_state)
+        
+        self.Xs_ = Xs
+        self.Xt_ = Xt
+        
+        n = len(Xs)
+        m = len(Xt)
+        
+        # Compute Kernel Matrix K
+        kernel_params = {k: v for k, v in self.__dict__.items()
+                         if k in KERNEL_PARAMS[self.kernel]}
+        
+        Kss = pairwise.pairwise_kernels(Xs, Xs, metric=self.kernel, **kernel_params)
+        Ktt = pairwise.pairwise_kernels(Xt, Xt, metric=self.kernel, **kernel_params)
+        Kst = pairwise.pairwise_kernels(Xs, Xt, metric=self.kernel, **kernel_params)
+
+        K = np.concatenate((Kss, Kst), axis=1)
+        K = np.concatenate((K, np.concatenate((Kst.transpose(), Ktt), axis=1)), axis=0)
+        
+        # Compute L
+        Lss = np.ones((n,n)) * (1./(n**2))
+        Ltt = np.ones((m,m)) * (1./(m**2))
+        Lst = np.ones((n,m)) * (-1./(n*m))
+
+        L = np.concatenate((Lss, Lst), axis=1)
+        L = np.concatenate((L, np.concatenate((Lst.transpose(), Ltt), axis=1)), axis=0)
+        
+        # Compute H
+        H = np.eye(n+m) - 1/(n+m) * np.ones((n+m, n+m))
+        
+        # Compute solution
+        a = np.eye(n+m) + self.mu * K.dot(L.dot(K))
+        b = K.dot(H.dot(K))
+        sol = linalg.lstsq(a, b)[0]
+        
+        values, vectors = linalg.eigh(sol)
+        
+        args = np.argsort(np.abs(values))[::-1][:self.n_components]
+
+        self.vectors_ = np.real(vectors[:, args])
+
+        Xs_enc = K.dot(self.vectors_)[:n]
+
+        return Xs_enc
+
+
+    def transform(self, X, domain="tgt"):
+        """
+        Return aligned features for X.
+
+        Parameters
+        ----------
+        X : array
+            Input data.
+
+        domain : str (default="tgt")
+            Choose between ``"source", "src"`` or
+            ``"target", "tgt"`` feature embedding.
+
+        Returns
+        -------
+        X_emb : array
+            Embeddings of X.
+        """
+        X = check_array(X)
+        
+        kernel_params = {k: v for k, v in self.__dict__.items()
+                         if k in KERNEL_PARAMS[self.kernel]}
+        
+        Kss = pairwise.pairwise_kernels(X, self.Xs_, metric=self.kernel, **kernel_params)
+        Kst = pairwise.pairwise_kernels(X, self.Xt_, metric=self.kernel, **kernel_params)
+
+        K = np.concatenate((Kss, Kst), axis=1)
+        
+        return K.dot(self.vectors_)

tests/test_tca.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+from adapt.metrics import normalized_linear_discrepancy
+from adapt.feature_based import TCA
+
+np.random.seed(0)
+n = 50
+m = 50
+p = 6
+
+Xs = np.random.randn(m, p)*0.1 + np.array([0.]*(p-2) + [2., 2.])
+Xt = np.random.randn(n, p)*0.1
+
+
+def test_tca():
+    tca = TCA(n_components=2, kernel="rbf", gamma=0.01, random_state=0)
+    Xst = tca.fit_transform(Xs, Xt)
+    assert np.abs(Xst - tca.transform(Xs, "src")).sum() < 10**-8
+    assert Xst.shape[1] == 2
+    assert (normalized_linear_discrepancy(Xs, Xt) >
+            2 * normalized_linear_discrepancy(Xst, tca.transform(Xt)))