Add tests instancebased and base

antoinedemathelin · antoinedemathelin · commit 1efbd7bde084 · 2022-01-05T15:28:33.000+01:00
diff --git a/adapt/base.py b/adapt/base.py
@@ -363,6 +363,7 @@ def _save_validation_data(self, Xs, Xt):
             size = min(self.val_sample_size, len(Xt))
             tgt_index = np.random.choice(len(Xt), size, replace=False)
             self.Xt_ = Xt[tgt_index]
+            self.src_index_ = src_index
         else:
             self.Xs_ = Xs
             self.Xt_ = Xt
@@ -780,9 +781,20 @@ def _get_config_keras_model(self, model):
         config = model.get_config()
         klass = model.__class__
         
-        return dict(weights=weights,
-                    config=config,
-                    klass=klass)
+        config = dict(weights=weights,
+                     config=config,
+                     klass=klass)
+        
+        if hasattr(model, "loss"):
+            config["loss"] = model.loss
+            
+        if hasattr(model, "optimizer"):
+            try:
+                config["optimizer_klass"] = model.optimizer.__class__
+                config["optimizer_config"] = model.optimizer.get_config()
+            except:
+                pass
+        return config
 
 
     def _from_config_keras_model(self, dict_):
@@ -794,6 +806,16 @@ def _from_config_keras_model(self, dict_):
 
         if weights is not None:
             model.set_weights(weights)
+        
+        if "loss" in dict_ and "optimizer_klass" in dict_:
+            loss = dict_["loss"]
+            optimizer = dict_["optimizer_klass"].from_config(
+                    dict_["optimizer_config"])
+            try:
+                model.compile(loss=loss, optimizer=optimizer)
+            except:
+                print("Unable to compile model")
+        
         return model
 
 
@@ -1414,14 +1436,6 @@ def _initialize_weights(self, shape_X):
             X_enc = self.encoder_(np.zeros((1,) + shape_X))
             if hasattr(self, "discriminator_"):
                 self.discriminator_(X_enc)
-    
-    
-    def _check_pretrain(self, params):
-        self.pretrain = False
-        for param in params:
-            if "pretrain__" in param:
-                self.pretrain = True
-                break
 
 
     def _unpack_data(self, data):
diff --git a/adapt/instance_based/_tradaboost.py b/adapt/instance_based/_tradaboost.py
@@ -804,7 +804,7 @@ def _boost(self, iboost, Xs, ys, Xt, yt,
         ys_pred = estimator.predict(Xs)
         yt_pred = estimator.predict(Xt)
         
-        if ys_pred.ndim == 1:
+        if ys_pred.ndim == 1 or ys.ndim == 1:
             ys = ys.reshape(-1, 1)
             yt = yt.reshape(-1, 1)
             ys_pred = ys_pred.reshape(-1, 1)
diff --git a/adapt/instance_based/_wann.py b/adapt/instance_based/_wann.py
@@ -52,6 +52,13 @@ class WANN(BaseAdaptDeep):
         
     history_ : dict
         history of the losses and metrics across the epochs.
+        
+    
+    References
+    ----------
+    .. [1] `[1] <https://arxiv.org/pdf/2006.08251.pdf>`_ A. de Mathelin, \
+G. Richard, F. Deheeger, M. Mougeot and N. Vayatis  "Adversarial Weighting \
+for Domain Adaptation in Regression". In ICTAI, 2021.
     """
     
     def __init__(self,
diff --git a/tests/test_base.py b/tests/test_base.py
@@ -2,6 +2,7 @@
 Test base
 """
 
+import copy
 import shutil
 import numpy as np
 import pytest
@@ -26,6 +27,30 @@
 yt = 0.2 * Xt[:, 0].ravel()
 
 
+class DummyFeatureBased(BaseAdaptEstimator):
+    
+    def fit_transform(self, Xs, **kwargs):
+        return Xs
+    
+    def transform(self, Xs):
+        return Xs
+    
+    
+class DummyInstanceBased(BaseAdaptEstimator):
+    
+    def fit_weights(self, Xs, **kwargs):
+        return np.ones(len(Xs))
+    
+    def predict_weights(self):
+        return np.ones(100)
+    
+    
+class DummyParameterBased(BaseAdaptEstimator):
+    
+    def fit(self, Xs, ys):
+        return self.fit_estimator(Xs, ys)
+
+
 def test_base_adapt_estimator():
     base_adapt = BaseAdaptEstimator(Xt=Xt)
     for check in check_estimator(base_adapt, generate_only=True):
@@ -37,7 +62,78 @@ def test_base_adapt_estimator():
             else:
                 raise
                 
-                
+
+def test_base_adapt_score():
+    model = DummyParameterBased(Xt=Xt, random_state=0)
+    model.fit(Xs, ys)
+    model.score(Xt, yt)
+    
+    model = DummyFeatureBased(Xt=Xt, random_state=0)
+    model.fit(Xs, ys)
+    s1 = model.score(Xt, yt)
+    s2 = model._score_adapt(Xs, Xt)
+    assert s1 == s2
+    
+    model = DummyInstanceBased(Xt=Xt, random_state=0)
+    model.fit(Xs, ys)
+    model.score(Xt, yt)
+    s1 = model.score(Xt, yt)
+    s2 = model._score_adapt(Xs, Xt)
+    assert s1 == s2
+    
+    
+def test_base_adapt_val_sample_size():
+    model = DummyFeatureBased(Xt=Xt, random_state=0, val_sample_size=10)
+    model.fit(Xs, ys)
+    model.score(Xt, yt)
+    assert len(model.Xs_) == 10
+    assert len(model.Xt_) == 10
+    assert np.all(model.Xs_ == Xs[model.src_index_])
+    
+
+def test_base_adapt_keras_estimator():
+    est = Sequential()
+    est.add(Dense(1, input_shape=Xs.shape[1:]))
+    est.compile(loss="mse", optimizer=Adam(0.01))
+    model = BaseAdaptEstimator(est, Xt=Xt)
+    model.fit(Xs, ys)
+    assert model.estimator_.loss == "mse"
+    assert isinstance(model.estimator_.optimizer, Adam)
+    assert model.estimator_.optimizer.learning_rate == 0.01
+    
+    model = BaseAdaptEstimator(est, Xt=Xt, loss="mae",
+                               optimizer=Adam(0.01, beta_1=0.5),
+                               learning_rate=0.1)
+    model.fit(Xs, ys)
+    assert model.estimator_.loss == "mae"
+    assert isinstance(model.estimator_.optimizer, Adam)
+    assert model.estimator_.optimizer.learning_rate == 0.1
+    assert model.estimator_.optimizer.beta_1 == 0.5
+    
+    model = BaseAdaptEstimator(est, Xt=Xt, optimizer="sgd")
+    model.fit(Xs, ys)
+    assert not isinstance(model.estimator_.optimizer, Adam)
+    
+    est = Sequential()
+    est.add(Dense(1, input_shape=Xs.shape[1:]))
+    model = BaseAdaptEstimator(est, Xt=Xt, loss="mae",
+                               optimizer=Adam(0.01, beta_1=0.5),
+                               learning_rate=0.1)
+    model.fit(Xs, ys)
+    assert model.estimator_.loss == "mae"
+    assert isinstance(model.estimator_.optimizer, Adam)
+    assert model.estimator_.optimizer.learning_rate == 0.1
+    assert model.estimator_.optimizer.beta_1 == 0.5
+    
+    s1 = model.score_estimator(Xt[:10], yt[:10])
+    s2 = model.estimator_.evaluate(Xt[:10], yt[:10])
+    assert s1 == s2
+    
+    copy_model = copy.deepcopy(model)
+    assert s1 == copy_model.score_estimator(Xt[:10], yt[:10])
+    assert hex(id(model)) != hex(id(copy_model))
+
+
 def test_base_adapt_deep():
     model = BaseAdaptDeep(Xt=Xt, loss="mse", optimizer=Adam(), learning_rate=0.1)
     model.fit(Xs, ys)
@@ -52,8 +148,8 @@ def test_base_adapt_deep():
     assert hasattr(model, "encoder_")
     assert hasattr(model, "task_")
     assert hasattr(model, "discriminator_")
-    
-    
+
+
 def test_base_adapt_deep():
     model = BaseAdaptDeep(Xt=Xt, loss="mse",
                           epochs=2,
@@ -63,6 +159,7 @@ def test_base_adapt_deep():
     model.fit(Xs, ys)
     yp = model.predict(Xt)
     score = model.score(Xt, yt)
+    score_est = model.score_estimator(Xt, yt)
     X_enc = model.transform(Xs)
     ypt = model.predict_task(Xt)
     ypd = model.predict_disc(Xt)
@@ -71,6 +168,7 @@ def test_base_adapt_deep():
     new_model.fit(Xs, ys)
     yp2 = new_model.predict(Xt)
     score2 = new_model.score(Xt, yt)
+    score_est2 = new_model.score_estimator(Xt, yt)
     X_enc2 = new_model.transform(Xs)
     ypt2 = new_model.predict_task(Xt)
     ypd2 = new_model.predict_disc(Xt)
@@ -88,6 +186,7 @@ def test_base_adapt_deep():
     
     assert np.all(yp == yp2)
     assert score == score2
+    assert score_est == score_est2
     assert np.all(ypt == ypt2)
     assert np.all(ypd == ypd2)
     assert np.all(X_enc == X_enc2)
diff --git a/tests/test_kliep.py b/tests/test_kliep.py
@@ -47,6 +47,8 @@ def test_fit():
     assert model.weights_[:50].sum() > 90
     assert model.weights_[50:].sum() < 0.5
     assert np.abs(model.predict(Xt) - yt).sum() < 20
+    assert np.all(model.weights_ == model.predict_weights())
+    assert np.all(model.weights_ == model.predict_weights(Xs))
     
 
 def test_fit_estimator_bootstrap_index():
diff --git a/tests/test_kmm.py b/tests/test_kmm.py
@@ -32,4 +32,24 @@ def test_fit():
     assert np.abs(model.estimator_.coef_[0][0] - 0.2) < 1
     assert model.weights_[:50].sum() > 50
     assert model.weights_[50:].sum() < 0.1
-    assert np.abs(model.predict(Xt) - yt).sum() < 10
+    assert np.abs(model.predict(Xt) - yt).sum() < 10
+    assert np.all(model.weights_ == model.predict_weights())
+    
+    
+def test_tol():
+    np.random.seed(0)
+    model = KMM(LinearRegression(fit_intercept=False), gamma=1., tol=0.1)
+    model.fit(Xs, ys, Xt=Xt)
+    assert np.abs(model.estimator_.coef_[0][0] - 0.2) > 5
+    
+    
+def test_batch():
+    np.random.seed(0)
+    model = KMM(LinearRegression(fit_intercept=False), gamma=1.,
+                max_size=35)
+    model.fit(Xs, ys, Xt=Xt)
+    assert np.abs(model.estimator_.coef_[0][0] - 0.2) < 1
+    assert model.weights_[:50].sum() > 50
+    assert model.weights_[50:].sum() < 0.1
+    assert np.abs(model.predict(Xt) - yt).sum() < 10
+    assert np.all(model.weights_ == model.predict_weights())
diff --git a/tests/test_tradaboost.py b/tests/test_tradaboost.py
@@ -2,8 +2,10 @@
 Test functions for tradaboost module.
 """
 
+import copy
 import numpy as np
 from sklearn.linear_model import LinearRegression, LogisticRegression
+import tensorflow as tf
 
 from adapt.instance_based import (TrAdaBoost,
                                   TrAdaBoostR2,
@@ -40,6 +42,23 @@ def test_tradaboost_fit():
     assert (model.predict(Xt).ravel() == yt_classif).sum() > 90
     
     
+def test_tradaboost_fit_keras_model():
+    np.random.seed(0)
+    est = tf.keras.Sequential()
+    est.add(tf.keras.layers.Dense(1, activation="sigmoid"))
+    est.compile(loss="bce", optimizer="adam")
+    model = TrAdaBoost(est, n_estimators=2, random_state=0)
+    model.fit(Xs, ys_classif, Xt=Xt[:10], yt=yt_classif[:10])
+    yp = model.predict(Xt)
+    
+    est = tf.keras.Sequential()
+    est.add(tf.keras.layers.Dense(2, activation="softmax"))
+    est.compile(loss="mse", optimizer="adam")
+    model = TrAdaBoost(est, n_estimators=2, random_state=0)
+    model.fit(Xs, np.random.random((100, 2)),
+              Xt=Xt[:10], yt=np.random.random((10, 2)))
+    
+    
 def test_tradaboostr2_fit():
     np.random.seed(0)
     model = TrAdaBoostR2(LinearRegression(fit_intercept=False),
@@ -51,16 +70,36 @@ def test_tradaboostr2_fit():
             model.sample_weights_src_[-1][50:].sum()) > 10
     assert model.sample_weights_tgt_[-1].sum() > 0.7
     assert np.abs(model.predict(Xt) - yt_reg).sum() < 1
+    assert np.all(model.predict_weights(domain="src") ==
+                  model.sample_weights_src_[-1])
+    assert np.all(model.predict_weights(domain="tgt") ==
+                  model.sample_weights_tgt_[-1])
 
 
 def test_twostagetradaboostr2_fit():
     np.random.seed(0)
     model = TwoStageTrAdaBoostR2(LinearRegression(fit_intercept=False),
                          n_estimators=10)
-    model.fit(Xs, ys_reg, Xt=Xt[:10], yt=yt_reg[:10])
+    model.fit(Xs, ys_reg.ravel(), Xt=Xt[:10], yt=yt_reg[:10].ravel())    
     assert np.abs(model.estimators_[-1].estimators_[-1].coef_[0]
            - 1.) < 1
     assert np.abs(model.sample_weights_src_[-1][:50].sum() / 
             model.sample_weights_src_[-1][50:].sum()) > 10
     assert model.sample_weights_tgt_[-1].sum() > 0.7
     assert np.abs(model.predict(Xt) - yt_reg).sum() < 1
+    argmin = np.argmin(model.estimator_errors_)
+    assert np.all(model.predict_weights(domain="src") ==
+                  model.sample_weights_src_[argmin])
+    assert np.all(model.predict_weights(domain="tgt") ==
+                  model.sample_weights_tgt_[argmin])
+    
+    
+def test_tradaboost_deepcopy():
+    np.random.seed(0)
+    model = TrAdaBoost(LogisticRegression(penalty='none',
+                       solver='lbfgs'),
+                       n_estimators=20)
+    model.fit(Xs, ys_classif, Xt=Xt[:10], yt=yt_classif[:10])
+    copy_model = copy.deepcopy(model)
+    assert np.all(model.predict(Xt) == copy_model.predict(Xt))
+    assert hex(id(model)) != hex(id(copy_model))
