update docs

Author: antoinedemathelin

adapt/base.py

@@ -123,11 +123,11 @@ class ADDA(BaseAdaptDeep):
     >>> ys = 0.2 * Xs[:, 0]
     >>> yt = 0.2 * Xt[:, 0]
     >>> model = ADDA(random_state=0)
-    >>> model.fit(Xs, ys, Xt, yt, epochs=100, verbose=0)
-    >>> model.history_src_["task_t"][-1]
-    0.0234...
-    >>> model.history_["task_t"][-1]
-    0.0009...
+    >>> model.fit(Xs, ys, Xt, epochs=100, verbose=0)
+    >>> np.abs(model.predict_task(Xt, domain="src").ravel() - yt).mean()
+    0.1531...
+    >>> np.abs(model.predict_task(Xt, domain="tgt").ravel() - yt).mean()
+    0.0227...
     
     See also
     --------
@@ -242,8 +242,6 @@ def train_step(self, data):
                 disc_loss += sum(self.discriminator_.losses)
                 enc_loss += sum(self.encoder_.losses)
 
-            print(task_loss.shape, enc_loss.shape, disc_loss.shape)
-
             # Compute gradients
             trainable_vars_task = self.task_.trainable_variables
             trainable_vars_enc = self.encoder_.trainable_variables

adapt/feature_based/_adda.py

@@ -43,10 +43,10 @@ class CDAN(BaseAdaptDeep):
     .. math::
     
         \min_{\phi, F} & \; \mathcal{L}_{task}(F(\phi(X_S)), y_S) -
-        \lambda \\left( \log(1 - D(\phi(X_S) \\bigotimes F(X_S)) + \\\\
-        \log(D(\phi(X_T) \\bigotimes F(X_T)) \\right) \\\\
-        \max_{D} & \; \log(1 - D(\phi(X_S) \\bigotimes F(X_S)) + \\\\
-        \log(D(\phi(X_T) \\bigotimes F(X_T))
+        \lambda \\left( \log(1 - D(\phi(X_S) \\otimes F(X_S)) +
+        \log(D(\phi(X_T) \\otimes F(X_T)) \\right) \\\\
+        \max_{D} & \; \log(1 - D(\phi(X_S) \\otimes F(X_S)) +
+        \log(D(\phi(X_T) \\otimes F(X_T))
         
     Where:
     
@@ -55,7 +55,7 @@ class CDAN(BaseAdaptDeep):
     - :math:`\phi, F, D` are respectively the **encoder**, the **task**
       and the **discriminator** networks
     - :math:`\lambda` is the trade-off parameter.
-    - :math:`\phi(X_S) \\bigotimes F(X_S)` is the multilinear map between
+    - :math:`\phi(X_S) \\otimes F(X_S)` is the multilinear map between
       the encoded sources and the task predictions.
     
     In CDAN+E, an entropy regularization is added to prioritize the
@@ -65,15 +65,15 @@ class CDAN(BaseAdaptDeep):
     .. math::
     
         \min_{\phi, F} & \; \mathcal{L}_{task}(F(\phi(X_S)), y_S) -
-        \lambda \\left( \log(1 - W_S D(\phi(X_S) \\bigotimes F(X_S)) + \\\\
-        W_T \log(D(\phi(X_T) \\bigotimes F(X_T)) \\right) \\\\
-        \max_{D} & \; \log(1 - W_S D(\phi(X_S) \\bigotimes F(X_S)) + \\\\
-        W_T \log(D(\phi(X_T) \\bigotimes F(X_T))
+        \lambda \\left( \log(1 - W_S D(\phi(X_S) \\otimes F(X_S)) +
+        W_T \log(D(\phi(X_T) \\otimes F(X_T)) \\right) \\\\
+        \max_{D} & \; \log(1 - W_S D(\phi(X_S) \\otimes F(X_S)) +
+        W_T \log(D(\phi(X_T) \\otimes F(X_T))
         
     Where:
     
-    - :math:`W_S = 1+\exp{-\\text{entropy}(F(X_S))}`
-    - :math:`\\text{entropy}(F(X_S)) = - \sum_{i < C} F(X_S)_i \log(F(X_S)_i)`
+    - :math:`W_S = 1+\exp^{-\\text{ent}(F(X_S))}`
+    - :math:`\\text{ent}(F(X_S)) = - \sum_{i < C} F(X_S)_i \log(F(X_S)_i)`
       with :math:`C` the number of classes.
       
     .. figure:: ../_static/images/cdan.png

adapt/feature_based/_cdan.py

@@ -41,8 +41,8 @@ class CORAL(BaseAdaptEstimator):
     and the features transformation can be computed through this
     four steps algorithm:
     
-    - :math:`C_S = \\lambda Cov(X_S) + I_p`
-    - :math:`C_T = \\lambda Cov(X_T) + I_p`
+    - :math:`C_S = Cov(X_S) + \\lambda I_p`
+    - :math:`C_T = Cov(X_T) + \\lambda I_p`
     - :math:`X_S = X_S C_S^{-\\frac{1}{2}}`
     - :math:`X_S^{enc} = X_S C_T^{\\frac{1}{2}}`
     
@@ -80,22 +80,22 @@ class CORAL(BaseAdaptEstimator):
     >>> yt = np.zeros(100)
     >>> ys[Xs[:, 1]>0] = 1
     >>> yt[(Xt[:, 1]-0.5*Xt[:, 0])>0] = 1
-    >>> model = CORAL(lambda_=0.)
+    >>> model = CORAL(lambda_=1000.)
     >>> model.fit(Xs, ys, Xt);
     Covariance Matrix alignement...
     Previous covariance difference: 0.258273
-    New covariance difference: 0.258273
+    New covariance difference: 0.258072
     Fit estimator...
     >>> model.estimator_.score(Xt, yt)
     0.5750...
-    >>> model = CORAL(lambda_=100.)
+    >>> model = CORAL(lambda_=0.)
     >>> model.fit(Xs, ys, Xt);
     Covariance Matrix alignement...
     Previous covariance difference: 0.258273
-    New covariance difference: 0.040564
+    New covariance difference: 0.000000
     Fit estimator...
     >>> model.estimator_.score(Xt, yt)
-    0.5992...
+    0.5717...
         
     See also
     --------

adapt/feature_based/_coral.py

@@ -96,13 +96,13 @@ class DANN(BaseAdaptDeep):
     >>> ys = 0.2 * Xs[:, 0]
     >>> yt = 0.2 * Xt[:, 0]
     >>> model = DANN(lambda_=0., random_state=0)
-    >>> model.fit(Xs, ys, Xt, yt, epochs=100, verbose=0)
-    >>> model.history_["task_t"][-1]
-    0.0240...
+    >>> model.fit(Xs, ys, Xt, epochs=100, verbose=0)
+    >>> model.score_estimator(Xt, yt)
+    0.0231...
     >>> model = DANN(lambda_=0.1, random_state=0)
-    >>> model.fit(Xs, ys, Xt, yt, epochs=100, verbose=0)
-    >>> model.history_["task_t"][-1]
-    0.0022...
+    >>> model.fit(Xs, ys, Xt, epochs=100, verbose=0)
+    >>> model.score_estimator(Xt, yt)
+    0.0010...
     
     See also
     --------
@@ -185,7 +185,6 @@ def train_step(self, data):
             disc_loss += sum(self.discriminator_.losses)
             enc_loss += sum(self.encoder_.losses)
 
-        print(task_loss.shape, enc_loss.shape, disc_loss.shape)
 
         # Compute gradients
         trainable_vars_task = self.task_.trainable_variables
@@ -209,7 +208,6 @@ def train_step(self, data):
         disc_metrics = self._get_disc_metrics(ys_disc, yt_disc)
         logs.update({"disc_loss": disc_loss})
         logs.update(disc_metrics)
-        logs.update({"lambda": _lambda_})
         return logs
 
 

adapt/feature_based/_dann.py

@@ -6,7 +6,7 @@
 import tensorflow as tf
 
 from adapt.base import BaseAdaptDeep, make_insert_doc
-from adapt.utils import check_network
+from adapt.utils import check_network, get_default_encoder, get_default_task
 
 EPS = np.finfo(np.float32).eps
 
@@ -93,13 +93,13 @@ class DeepCORAL(BaseAdaptDeep):
     >>> ys[Xs[:, 1]>0] = 1
     >>> yt[(Xt[:, 1]-0.5*Xt[:, 0])>0] = 1
     >>> model = DeepCORAL(lambda_=0., random_state=0)
-    >>> model.fit(Xs, ys, Xt, yt, epochs=500, batch_size=100, verbose=0)
-    >>> model.history_["task_t"][-1]
-    1.30188e-05
+    >>> model.fit(Xs, ys, Xt, epochs=500, batch_size=100, verbose=0)
+    >>> model.score_estimator(Xt, yt)
+    0.0574...
     >>> model = DeepCORAL(lambda_=1., random_state=0)
-    >>> model.fit(Xs, ys, Xt, yt, epochs=500, batch_size=100, verbose=0)
-    >>> model.history_["task_t"][-1]
-    5.4704474e-06
+    >>> model.fit(Xs, ys, Xt, epochs=500, batch_size=100, verbose=0)
+    >>> model.score_estimator(Xt, yt)
+    0.0649...
         
     See also
     --------
@@ -200,8 +200,6 @@ def train_step(self, data):
 
             loss += sum(self.task_.losses) + sum(self.encoder_.losses)
 
-        print(cov_src.shape, cov_tgt.shape, disc_loss.shape)
-            
         # Compute gradients
         trainable_vars = self.task_.trainable_variables + self.encoder_.trainable_variables
 

adapt/feature_based/_deepcoral.py

@@ -80,9 +80,9 @@ class FE(BaseAdaptEstimator):
     Previous shape: (100, 1)
     New shape: (100, 3)
     Fit estimator...
-    >>> np.abs(model.predict(Xt, "src") - yt).mean()
+    >>> np.abs(model.predict(Xt, domain="src") - yt).mean()
     0.9846...
-    >>> np.abs(model.predict(Xt, "tgt") - yt).mean()
+    >>> np.abs(model.predict(Xt, domain="tgt") - yt).mean()
     0.1010...
 
     References

adapt/feature_based/_fe.py

@@ -174,7 +174,6 @@ def train_step(self, data):
                 disc_loss += sum(self.discriminator_.losses)
                 enc_loss += sum(self.encoder_.losses)
 
-            print(discrepancy.shape, enc_loss.shape, disc_loss.shape)
 
             # Compute gradients
             trainable_vars_task = self.task_.trainable_variables

adapt/feature_based/_mcd.py

@@ -120,7 +120,6 @@ def train_step(self, data):
 
             # Compute Disc
             if name == "categorical_crossentropy":
-                print("ok")
                 argmax_src = tf.one_hot(tf.math.argmax(ys_pred, -1),
                              tf.shape(ys_pred)[1])
                 argmax_tgt = tf.one_hot(tf.math.argmax(yt_pred, -1),
@@ -147,7 +146,6 @@ def train_step(self, data):
             disc_loss += sum(self.discriminator_.losses)
             enc_loss += sum(self.encoder_.losses)
 
-        print(task_loss.shape, enc_loss.shape, disc_loss.shape)
 
         # Compute gradients
         trainable_vars_task = self.task_.trainable_variables

adapt/feature_based/_mdd.py

@@ -90,12 +90,12 @@ class WDGRL(BaseAdaptDeep):
     >>> yt = 0.2 * Xt[:, 0]
     >>> model = WDGRL(lambda_=0., random_state=0)
     >>> model.fit(Xs, ys, Xt, yt, epochs=100, verbose=0)
-    >>> model.history_["task_t"][-1]
-    0.0223...
+    >>> model.score_estimator(Xt, yt)
+    0.0231...
     >>> model = WDGRL(lambda_=1, random_state=0)
     >>> model.fit(Xs, ys, Xt, yt, epochs=100, verbose=0)
-    >>> model.history_["task_t"][-1]
-    0.0044...
+    >>> model.score_estimator(Xt, yt)
+    0.0014...
         
     See also
     --------
@@ -181,8 +181,6 @@ def train_step(self, data):
             disc_loss += sum(self.discriminator_.losses)
             enc_loss += sum(self.encoder_.losses)
 
-        print(task_loss.shape, enc_loss.shape, disc_loss.shape)
-            
         # Compute gradients
         trainable_vars_task = self.task_.trainable_variables
         trainable_vars_enc = self.encoder_.trainable_variables