update tests

Author: antoinedemathelin

adapt/feature_based/_cdan.py

@@ -278,8 +278,9 @@ def train_step(self, data):
 
         # Update weights
         self.optimizer.apply_gradients(zip(gradients_task, trainable_vars_task))
-        self.optimizer_enc.apply_gradients(zip(gradients_enc, trainable_vars_enc))
         self.optimizer_disc.apply_gradients(zip(gradients_disc, trainable_vars_disc))
+        if len(gradients_enc) > 0:
+            self.optimizer_enc.apply_gradients(zip(gradients_enc, trainable_vars_enc))
 
         # Update metrics
         logs = self._update_logs(ys, ys_pred)
@@ -334,21 +335,6 @@ def _initialize_networks(self):
             self.discriminator_ = check_network(self.discriminator,
                                                 copy=self.copy,
                                                 name="discriminator")
-        
-    
-    
-    # def _initialize_networks(self, shape_Xt):
-        # Call predict to avoid strange behaviour with
-        # Sequential model whith unspecified input_shape
-        # zeros_enc_ = self.encoder_.predict(np.zeros((1,) + shape_Xt));
-        # zeros_task_ = self.task_.predict(zeros_enc_);
-        # if zeros_task_.shape[1] * zeros_enc_.shape[1] > self.max_features:
-        #     self.discriminator_.predict(np.zeros((1, self.max_features)))
-        # else:
-        #     zeros_mapping_ = np.matmul(np.expand_dims(zeros_enc_, 2),
-        #                                np.expand_dims(zeros_task_, 1))
-        #     zeros_mapping_ = np.reshape(zeros_mapping_, (1, -1))
-        #     self.discriminator_.predict(zeros_mapping_);
 
 
     def predict_disc(self, X):

adapt/feature_based/_wdgrl.py

@@ -183,10 +183,7 @@ def train_step(self, data):
         self.optimizer_disc.apply_gradients(zip(gradients_disc, trainable_vars_disc))
 
         # Update metrics
-        self.compiled_metrics.update_state(ys, ys_pred)
-        self.compiled_loss(ys, ys_pred)
-        # Return a dict mapping metric names to current value
-        logs = {m.name: m.result() for m in self.metrics}
+        logs = self._update_logs(ys, ys_pred)
         disc_metrics = self._get_disc_metrics(ys_disc, yt_disc)
         logs.update(disc_metrics)
         logs.update({"gp": penalty})

adapt/parameter_based/_regular.py

@@ -412,41 +412,65 @@ def _initialize_networks(self):
         else:
             self.task_ = check_network(self.task,
                                        copy=self.copy,
+                                       force_copy=True,
                                        name="task")
+
+
+    def _initialize_weights(self, shape_X):
+        if hasattr(self, "task_"):
+            self.task_.build((None,) + shape_X)
+        self.build((None,) + shape_X)
         self._add_regularization()
 
 
-    def _get_regularizer(self, old_weight, weight, lambda_=1.):
+    def _get_regularizer(self, old_weight, weight, lambda_):
         if self.regularizer == "l2":
-            def regularizer():
-                return lambda_ * tf.reduce_mean(tf.square(old_weight - weight))
+            return lambda_ * tf.reduce_mean(tf.square(old_weight - weight))
         if self.regularizer == "l1":
-            def regularizer():
-                return lambda_ * tf.reduce_mean(tf.abs(old_weight - weight))
+            return lambda_ * tf.reduce_mean(tf.abs(old_weight - weight))
         return regularizer
 
 
+    def train_step(self, data):
+        # Unpack the data.
+        Xs, Xt, ys, yt = self._unpack_data(data)
+        
+        # Run forward pass.
+        with tf.GradientTape() as tape:
+            y_pred = self.task_(Xt, training=True)
+            if hasattr(self, "_compile_loss") and self._compile_loss is not None:
+                loss = self._compile_loss(yt, y_pred)
+            else:
+                loss = self.compiled_loss(yt, y_pred)
+            
+            loss = tf.reduce_mean(loss)
+            loss += sum(self.losses)
+            reg_loss = 0.
+            for i in range(len(self.task_.trainable_variables)):
+                reg_loss += self._get_regularizer(self.old_weights_[i],
+                                                  self.task_.trainable_variables[i],
+                                                  self.lambdas_[i])
+            loss += reg_loss
+
+        # Run backwards pass.
+        gradients = tape.gradient(loss, self.task_.trainable_variables)
+        self.optimizer.apply_gradients(zip(gradients, self.task_.trainable_variables))
+        return self._update_logs(yt, y_pred)
+
+
     def _add_regularization(self):
-        i = 0
+        self.old_weights_ = []
         if not hasattr(self.lambdas, "__iter__"):
-            lambdas = [self.lambdas]
+            self.lambdas_ = [self.lambdas] * len(self.task_.weights)
         else:
-            lambdas = self.lambdas
+            self.lambdas_ = (self.lambdas +
+                             [self.lambdas[-1]] * (len(self.task_.weights) - len(self.lambdas)))
+        self.lambdas_ = self.lambdas_[::-1]
 
-        for layer in reversed(self.task_.layers):
-            if (hasattr(layer, "weights") and 
-            layer.weights is not None and
-            len(layer.weights) != 0):
-                if i >= len(lambdas):
-                    lambda_ = lambdas[-1]
-                else:
-                    lambda_ = lambdas[i]
-                for weight in reversed(layer.weights):
-                    old_weight = tf.identity(weight)
-                    old_weight.trainable = False
-                    self.add_loss(self._get_regularizer(
-                        old_weight, weight, lambda_))
-                i += 1
+        for weight in self.task_.trainable_variables:
+            old_weight = tf.identity(weight)
+            old_weight.trainable = False
+            self.old_weights_.append(old_weight)
 
 
     def call(self, inputs):

tests/test_adda.py

@@ -6,7 +6,7 @@
 import numpy as np
 import tensorflow as tf
 from tensorflow.keras import Sequential, Model
-from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import Dense, Input
 from tensorflow.keras.initializers import GlorotUniform
 from tensorflow.keras.optimizers import Adam
 
@@ -26,7 +26,8 @@
 
 def _get_encoder(input_shape=Xs.shape[1:]):
     model = Sequential()
-    model.add(Dense(1, input_shape=input_shape,
+    model.add(Input(shape=input_shape))
+    model.add(Dense(1,
                     kernel_initializer="ones",
                     use_bias=False))
     model.compile(loss="mse", optimizer="adam")
@@ -35,8 +36,8 @@ def _get_encoder(input_shape=Xs.shape[1:]):
 
 def _get_discriminator(input_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(10,
-                    input_shape=input_shape,
                     kernel_initializer=GlorotUniform(seed=0),
                     activation="elu"))
     model.add(Dense(1,
@@ -48,10 +49,10 @@ def _get_discriminator(input_shape=(1,)):
 
 def _get_task(input_shape=(1,), output_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(np.prod(output_shape),
                     use_bias=False,
-                    kernel_initializer=GlorotUniform(seed=0),
-                    input_shape=input_shape))
+                    kernel_initializer=GlorotUniform(seed=0)))
     model.compile(loss="mse", optimizer=Adam(0.1))
     return model
 

tests/test_cdan.py

@@ -5,7 +5,7 @@
 import numpy as np
 import tensorflow as tf
 from tensorflow.keras import Sequential, Model
-from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import Dense, Input
 from tensorflow.keras.optimizers import Adam
 from tensorflow.keras.initializers import GlorotUniform
 
@@ -27,16 +27,17 @@ def _entropy(x):
 
 def _get_encoder(input_shape=Xs.shape[1:], units=10):
     model = Sequential()
-    model.add(Dense(units, input_shape=input_shape,
+    model.add(Input(shape=input_shape))
+    model.add(Dense(units,
                     kernel_initializer=GlorotUniform(seed=0),))
     model.compile(loss="mse", optimizer="adam")
     return model
 
 
 def _get_discriminator(input_shape=(10*2,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(10,
-                    input_shape=input_shape,
                     kernel_initializer=GlorotUniform(seed=0),
                     activation="relu"))
     model.add(Dense(1, activation="sigmoid", kernel_initializer=GlorotUniform(seed=0)))
@@ -46,9 +47,9 @@ def _get_discriminator(input_shape=(10*2,)):
 
 def _get_task(input_shape=(10,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(2,
                     kernel_initializer=GlorotUniform(seed=0),
-                    input_shape=input_shape,
                     activation="softmax"))
     model.compile(loss="mse", optimizer=Adam(0.1))
     return model

tests/test_dann.py

@@ -6,11 +6,8 @@
 import numpy as np
 import tensorflow as tf
 from tensorflow.keras import Sequential, Model
-from tensorflow.keras.layers import Dense
-try:
-    from tensorflow.keras.optimizers import Adam, SGD
-except:
-    from tensorflow.keras.optimizers.legacy import Adam, SGD
+from tensorflow.keras.layers import Dense, Input
+from tensorflow.keras.optimizers import Adam, SGD
 
 from adapt.feature_based import DANN
 from adapt.utils import UpdateLambda
@@ -30,7 +27,8 @@
 
 def _get_encoder(input_shape=Xs.shape[1:]):
     model = Sequential()
-    model.add(Dense(1, input_shape=input_shape,
+    model.add(Input(shape=input_shape))
+    model.add(Dense(1,
                     kernel_initializer="ones",
                     use_bias=False))
     model.compile(loss="mse", optimizer="adam")
@@ -39,8 +37,8 @@ def _get_encoder(input_shape=Xs.shape[1:]):
 
 def _get_discriminator(input_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(10,
-                    input_shape=input_shape,
                     kernel_initializer=GlorotUniform(seed=0),
                     activation="elu"))
     model.add(Dense(1,
@@ -52,10 +50,10 @@ def _get_discriminator(input_shape=(1,)):
 
 def _get_task(input_shape=(1,), output_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(np.prod(output_shape),
                     kernel_initializer=GlorotUniform(seed=0),
-                    use_bias=False,
-                    input_shape=input_shape))
+                    use_bias=False))
     model.compile(loss="mse", optimizer=Adam(0.1))
     return model
 

tests/test_mcd.py

@@ -5,7 +5,7 @@
 import numpy as np
 import tensorflow as tf
 from tensorflow.keras import Sequential, Model
-from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import Dense, Input
 from tensorflow.keras.optimizers import Adam
 from tensorflow.keras.initializers import GlorotUniform
 
@@ -25,7 +25,8 @@
 
 def _get_encoder(input_shape=Xs.shape[1:]):
     model = Sequential()
-    model.add(Dense(1, input_shape=input_shape,
+    model.add(Input(shape=input_shape))
+    model.add(Dense(1,
                     kernel_initializer="ones",
                     use_bias=False))
     model.compile(loss="mse", optimizer="adam")
@@ -34,8 +35,8 @@ def _get_encoder(input_shape=Xs.shape[1:]):
 
 def _get_discriminator(input_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(10,
-                    input_shape=input_shape,
                     kernel_initializer=GlorotUniform(seed=0),
                     activation="relu"))
     model.add(Dense(1,
@@ -47,10 +48,10 @@ def _get_discriminator(input_shape=(1,)):
 
 def _get_task(input_shape=(1,), output_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(np.prod(output_shape),
                     kernel_initializer=GlorotUniform(seed=0),
-                    use_bias=False,
-                    input_shape=input_shape))
+                    use_bias=False))
     model.compile(loss="mse", optimizer=Adam(0.1))
     return model
 

tests/test_mdd.py

@@ -5,7 +5,7 @@
 import numpy as np
 import tensorflow as tf
 from tensorflow.keras import Sequential, Model
-from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import Dense, Input
 from tensorflow.keras.optimizers import Adam
 from tensorflow.keras.initializers import GlorotUniform
 
@@ -25,17 +25,17 @@
 
 def _get_encoder(input_shape=Xs.shape[1:]):
     model = Sequential()
-    model.add(Dense(1, input_shape=input_shape,
-                    kernel_initializer="ones",
+    model.add(Input(shape=input_shape))
+    model.add(Dense(1, kernel_initializer="ones",
                     use_bias=False))
     model.compile(loss="mse", optimizer="adam")
     return model
 
 
 def _get_discriminator(input_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(10,
-                    input_shape=input_shape,
                     kernel_initializer=GlorotUniform(seed=0),
                     activation="relu"))
     model.add(Dense(1,
@@ -47,10 +47,10 @@ def _get_discriminator(input_shape=(1,)):
 
 def _get_task(input_shape=(1,), output_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(np.prod(output_shape),
                     use_bias=False,
-                    kernel_initializer=GlorotUniform(seed=0),
-                    input_shape=input_shape))
+                    kernel_initializer=GlorotUniform(seed=0)))
     model.compile(loss="mse", optimizer=Adam(0.1))
     return model
 

tests/test_regular.py

@@ -10,7 +10,7 @@
 from sklearn.base import clone
 import tensorflow as tf
 from tensorflow.keras import Sequential, Model
-from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import Dense, Input
 from tensorflow.keras.optimizers import Adam
 from tensorflow.keras.initializers import GlorotUniform
 
@@ -40,10 +40,10 @@
 
 def _get_network(input_shape=(1,), output_shape=(1,)):
     model = Sequential()
+    model.add(Input(shape=input_shape))
     model.add(Dense(np.prod(output_shape),
-                    input_shape=input_shape,
                     kernel_initializer=GlorotUniform(seed=0),
-                    use_bias=False))
+                    use_bias=True))
     model.compile(loss="mse", optimizer=Adam(0.1))
     return model
 
@@ -150,17 +150,20 @@ def test_regularnn_fit():
     tf.random.set_seed(0)
     np.random.seed(0)
     network = _get_network()
+    print(network.get_weights())
     network.fit(Xs, ys_reg, epochs=100, batch_size=100, verbose=0)
-    model = RegularTransferNN(network, lambdas=0., optimizer=Adam(0.1))
+    print(network.get_weights())
+    model = RegularTransferNN(network, lambdas=0., optimizer=Adam(0.1), loss="mse")
     model.fit(Xt, yt_reg, epochs=100, batch_size=100, verbose=0)
+    print(model.task_.get_weights())
     # assert np.abs(network.predict(Xs) - ys_reg).sum() < 1
-    assert np.sum(np.abs(network.get_weights()[0] - model.get_weights()[0])) > 4.
+    assert np.sum(np.abs(network.get_weights()[0] - model.task_.get_weights()[0])) > 4.
     assert np.abs(model.predict(Xt) - yt_reg).sum() < 10
 
     model = RegularTransferNN(network, lambdas=10000000., optimizer=Adam(0.1))
     model.fit(Xt, yt_reg, epochs=100, batch_size=100, verbose=0)
 
-    assert np.sum(np.abs(network.get_weights()[0] - model.get_weights()[0])) < 0.001
+    assert np.sum(np.abs(network.get_weights()[0] - model.task_.get_weights()[0])) < 0.001
     assert np.abs(model.predict(Xt) - yt_reg).sum() > 10