Merge pull request #19 from antoinedemathelin/master

fix: Fix bugs Deep methods

Author: antoinedemathelin

adapt/base.py

@@ -367,7 +367,7 @@ def _save_validation_data(self, Xs, Xt):
         else:
             self.Xs_ = Xs
             self.Xt_ = Xt
-            self.src_index_ = np.arange(len(Xs))
+            self.src_index_ = None
 
 
     def _get_target_data(self, X, y):
@@ -458,7 +458,7 @@ def fit(self, X, y, Xt=None, yt=None, domains=None, **fit_params):
         if yt is not None:
             Xt, yt = check_arrays(Xt, yt)
         else:
-            Xt = check_array(Xt)
+            Xt = check_array(Xt, ensure_2d=True, allow_nd=True)
         set_random_seed(self.random_state)
 
         self._save_validation_data(X, Xt)
@@ -857,7 +857,7 @@ def __init__(self,
         self._self_setattr_tracking = True
 
 
-    def fit(self, X, y, Xt=None, yt=None, domains=None, **fit_params):
+    def fit(self, X, y=None, Xt=None, yt=None, domains=None, **fit_params):
         """
         Fit Model. Note that ``fit`` does not reset
         the model but extend the training.
@@ -867,7 +867,7 @@ def fit(self, X, y, Xt=None, yt=None, domains=None, **fit_params):
         X : array or Tensor
             Source input data.
 
-        y : array or Tensor
+        y : array or Tensor (default=None)
             Source output data.
             
         Xt : array (default=None)
@@ -889,71 +889,126 @@ def fit(self, X, y, Xt=None, yt=None, domains=None, **fit_params):
         Returns
         -------
         self : returns an instance of self
-        """        
+        """
         set_random_seed(self.random_state)
 
         # 1. Initialize networks
         if not hasattr(self, "_is_fitted"):
             self._is_fitted = True
             self._initialize_networks()
-            self._initialize_weights(X.shape[1:])
+            if isinstance(X, tf.data.Dataset):
+                first_elem = next(iter(X))
+                if (not isinstance(first_elem, tuple) or
+                not len(first_elem)==2):
+                    raise ValueError("When first argument is a dataset. "
+                                     "It should return (x, y) tuples.")
+                else:
+                    shape = first_elem[0].shape
+            else:
+                shape = X.shape[1:]
+            self._initialize_weights(shape)
+            
+        # 2. Get Fit params
+        fit_params = self._filter_params(super().fit, fit_params)
 
-        # 2. Prepare dataset
+        verbose = fit_params.get("verbose", 1)
+        epochs = fit_params.get("epochs", 1)
+        batch_size = fit_params.pop("batch_size", 32)
+        shuffle = fit_params.pop("shuffle", True)
+        validation_data = fit_params.pop("validation_data", None)
+        validation_split = fit_params.pop("validation_split", 0.)
+        validation_batch_size = fit_params.pop("validation_batch_size", batch_size)
+        
+        # 3. Prepare datasets
+        
+        ### 3.1 Source
+        if not isinstance(X, tf.data.Dataset):
+            check_arrays(X, y)
+            if len(y.shape) <= 1:
+                y = y.reshape(-1, 1)
+            
+            # Single source
+            if domains is None:
+                self.n_sources_ = 1
+                
+                dataset_Xs = tf.data.Dataset.from_tensor_slices(X)
+                dataset_ys = tf.data.Dataset.from_tensor_slices(y)
+            
+            # Multisource
+            else:
+                domains = self._check_domains(domains)
+                self.n_sources_ = int(np.max(domains)+1)
+                
+                sizes = [np.sum(domains==dom)
+                         for dom in range(self.n_sources_)]
+                
+                max_size = np.max(sizes)
+                repeats = np.ceil(max_size/sizes)
+                
+                dataset_Xs = tf.data.Dataset.zip(tuple(
+                    tf.data.Dataset.from_tensor_slices(X[domains==dom]).repeat(repeats[dom])
+                    for dom in range(self.n_sources_))
+                )
+
+                dataset_ys = tf.data.Dataset.zip(tuple(
+                    tf.data.Dataset.from_tensor_slices(y[domains==dom]).repeat(repeats[dom])
+                    for dom in range(self.n_sources_))
+                )
+            
+            dataset_src = tf.data.Dataset.zip((dataset_Xs, dataset_ys))
+            
+        else:
+            dataset_src = X
+            
+        ### 3.2 Target
         Xt, yt = self._get_target_data(Xt, yt)
+        if not isinstance(Xt, tf.data.Dataset):
+            if yt is None:
+                check_array(Xt, ensure_2d=True, allow_nd=True)
+                dataset_tgt = tf.data.Dataset.from_tensor_slices(Xt)
 
-        check_arrays(X, y)
-        if len(y.shape) <= 1:
-            y = y.reshape(-1, 1)
+            else:
+                check_arrays(Xt, yt)
+            
+                if len(yt.shape) <= 1:
+                    yt = yt.reshape(-1, 1)
+                
+                dataset_Xt = tf.data.Dataset.from_tensor_slices(Xt)
+                dataset_yt = tf.data.Dataset.from_tensor_slices(yt)
+                dataset_tgt = tf.data.Dataset.zip((dataset_Xt, dataset_yt))
 
-        if yt is None:
-            yt = y
-            check_array(Xt)
         else:
-            check_arrays(Xt, yt)
-        
-        if len(yt.shape) <= 1:
-            yt = yt.reshape(-1, 1)
+            dataset_tgt = Xt
 
         self._save_validation_data(X, Xt)
 
-        domains = fit_params.pop("domains", None)
-        
-        if domains is None:
-            domains = np.zeros(len(X))
-        
-        domains = self._check_domains(domains)
-
-        self.n_sources_ = int(np.max(domains)+1)
-        
-        sizes = np.array(
-            [np.sum(domains==dom) for dom in range(self.n_sources_)]+
-            [len(Xt)])
-        
-        max_size = np.max(sizes)
-        repeats = np.ceil(max_size/sizes)
-        
-        dataset_X = tf.data.Dataset.zip(tuple(
-            tf.data.Dataset.from_tensor_slices(X[domains==dom]).repeat(repeats[dom])
-            for dom in range(self.n_sources_))+
-            (tf.data.Dataset.from_tensor_slices(Xt).repeat(repeats[-1]),)
-        )
-                                        
-        dataset_y = tf.data.Dataset.zip(tuple(
-            tf.data.Dataset.from_tensor_slices(y[domains==dom]).repeat(repeats[dom])
-            for dom in range(self.n_sources_))+
-            (tf.data.Dataset.from_tensor_slices(yt).repeat(repeats[-1]),)
-        )
-        
-        
-        # 3. Get Fit params
-        fit_params = self._filter_params(super().fit, fit_params)
-        
-        verbose = fit_params.get("verbose", 1)
-        epochs = fit_params.get("epochs", 1)
-        batch_size = fit_params.pop("batch_size", 32)
-        shuffle = fit_params.pop("shuffle", True)
+        # 4. Get validation data
+#         validation_data = self._check_validation_data(validation_data,
+#                                                       validation_batch_size,
+#                                                       shuffle)
+        
+        if validation_data is None and validation_split>0.:
+            if shuffle:
+                dataset_src = dataset_src.shuffle(buffer_size=1024)
+            frac = int(len(dataset_src)*validation_split)
+            validation_data = dataset_src.take(frac)
+            dataset_src = dataset_src.skip(frac)
+            validation_data = validation_data.batch(batch_size)
+            
+        # 5. Set datasets
+        try:
+            max_size = max(len(dataset_src), len(dataset_tgt))
+            repeat_src = np.ceil(max_size/len(dataset_src))
+            repeat_tgt = np.ceil(max_size/len(dataset_tgt))
+
+            dataset_src = dataset_src.repeat(repeat_src)
+            dataset_tgt = dataset_tgt.repeat(repeat_tgt)
+            
+            self.total_steps_ = float(np.ceil(max_size/batch_size)*epochs)
+        except:
+            pass
 
-        # 4. Pretraining
+        # 5. Pretraining
         if not hasattr(self, "pretrain_"):
             if not hasattr(self, "pretrain"):
                 self.pretrain_ = False
@@ -980,36 +1035,39 @@ def fit(self, X, y, Xt=None, yt=None, domains=None, **fit_params):
             pre_epochs = prefit_params.pop("epochs", epochs)
             pre_batch_size = prefit_params.pop("batch_size", batch_size)
             pre_shuffle = prefit_params.pop("shuffle", shuffle)
+            prefit_params.pop("validation_data", None)
+            prefit_params.pop("validation_split", None)
+            prefit_params.pop("validation_batch_size", None)
 
             if pre_shuffle:
-                dataset = tf.data.Dataset.zip((dataset_X, dataset_y)).shuffle(buffer_size=1024).batch(pre_batch_size)
+                dataset = tf.data.Dataset.zip((dataset_src, dataset_tgt)).shuffle(buffer_size=1024).batch(pre_batch_size)
             else:
-                dataset = tf.data.Dataset.zip((dataset_X, dataset_y)).batch(pre_batch_size)
+                dataset = tf.data.Dataset.zip((dataset_src, dataset_tgt)).batch(pre_batch_size)
 
-            hist = super().fit(dataset, epochs=pre_epochs, verbose=pre_verbose, **prefit_params)
+            hist = super().fit(dataset, validation_data=validation_data,
+                               epochs=pre_epochs, verbose=pre_verbose, **prefit_params)
 
             for k, v in hist.history.items():
                 self.pretrain_history_[k] = self.pretrain_history_.get(k, []) + v
 
             self._initialize_pretain_networks()
-            
-        # 5. Training
+        
+        # 6. Compile
         if (not self._is_compiled) or (self.pretrain_):
             self.compile()
 
         if not hasattr(self, "history_"):
             self.history_ = {}
 
+        # .7 Training
         if shuffle:
-            dataset = tf.data.Dataset.zip((dataset_X, dataset_y)).shuffle(buffer_size=1024).batch(batch_size)
+            dataset = tf.data.Dataset.zip((dataset_src, dataset_tgt)).shuffle(buffer_size=1024).batch(batch_size)
         else:
-            dataset = tf.data.Dataset.zip((dataset_X, dataset_y)).batch(batch_size)
-            
+            dataset = tf.data.Dataset.zip((dataset_src, dataset_tgt)).batch(batch_size)
+
         self.pretrain_ = False
-        self.steps_ = tf.Variable(0.)
-        self.total_steps_ = float(np.ceil(max_size/batch_size)*epochs)
 
-        hist = super().fit(dataset, **fit_params)
+        hist = super().fit(dataset, validation_data=validation_data, **fit_params)
 
         for k, v in hist.history.items():
             self.history_[k] = self.history_.get(k, []) + v
@@ -1188,6 +1246,12 @@ def compile(self,
         super().compile(
             **compile_params
         )
+        
+        # Set optimizer for encoder and discriminator
+        if not hasattr(self, "optimizer_enc"):
+            self.optimizer_enc = self.optimizer
+        if not hasattr(self, "optimizer_disc"):
+            self.optimizer_disc = self.optimizer
 
 
     def call(self, inputs):
@@ -1199,10 +1263,6 @@ def train_step(self, data):
         # Unpack the data.
         Xs, Xt, ys, yt = self._unpack_data(data)
 
-        # Single source
-        Xs = Xs[0]
-        ys = ys[0]
-        
         # Run forward pass.
         with tf.GradientTape() as tape:
             y_pred = self(Xs, training=True)
@@ -1376,7 +1436,7 @@ def score_estimator(self, X, y, sample_weight=None):
         score : float
             Score.
         """
-        if np.prod(X.shape) <= 10**8:
+        if hasattr(X, "shape") and np.prod(X.shape) <= 10**8:
             score = self.evaluate(
                     X, y,
                     sample_weight=sample_weight,
@@ -1390,6 +1450,22 @@ def score_estimator(self, X, y, sample_weight=None):
         if isinstance(score, (tuple, list)):
             score = score[0]
         return score
+    
+    
+#     def _check_validation_data(self, validation_data, batch_size, shuffle):
+#         if isinstance(validation_data, tuple):
+#             X_val = validation_data[0]
+#             y_val = validation_data[1]
+        
+#             validation_data = tf.data.Dataset.zip(
+#                 (tf.data.Dataset.from_tensor_slices(X_val),
+#                  tf.data.Dataset.from_tensor_slices(y_val))
+#             )
+#             if shuffle:
+#                 validation_data = validation_data.shuffle(buffer_size=1024).batch(batch_size)
+#             else:
+#                 validation_data = validation_data.batch(batch_size)
+#         return validation_data
 
 
     def _get_legal_params(self, params):
@@ -1405,7 +1481,7 @@ def _get_legal_params(self, params):
         if (optimizer is not None) and (not isinstance(optimizer, str)):
             legal_params_fct.append(optimizer.__init__)
 
-        legal_params = ["domain", "val_sample_size"]
+        legal_params = ["domain", "val_sample_size", "optimizer_enc", "optimizer_disc"]
         for func in legal_params_fct:
             args = [
                 p.name
@@ -1439,13 +1515,17 @@ def _initialize_weights(self, shape_X):
 
 
     def _unpack_data(self, data):
-        data_X = data[0]
-        data_y = data[1]
-        Xs = data_X[:-1]
-        Xt = data_X[-1]
-        ys = data_y[:-1]
-        yt = data_y[-1]
-        return Xs, Xt, ys, ys
+        data_src = data[0]
+        data_tgt = data[1]
+        Xs = data_src[0]
+        ys = data_src[1]
+        if isinstance(data_tgt, tuple):
+            Xt = data_tgt[0]
+            yt = data_tgt[1]
+            return Xs, Xt, ys, yt
+        else:
+            Xt = data_tgt
+            return Xs, Xt, ys, None
 
 
     def _get_disc_metrics(self, ys_disc, yt_disc):