[MRG] Modification source_target_merge function behaviours

skada/_mapping.py

@@ -13,11 +13,11 @@
 from .utils import (
     check_X_domain,
     check_X_y_domain,
-    source_target_split
+    source_target_split,
+    source_target_merge
 )
 from ._utils import (
-    _estimate_covariance,
-    _merge_source_target,
+    _estimate_covariance
 )
 
 from ._pipeline import make_da_pipeline
@@ -90,7 +90,9 @@ def adapt(self, X, y=None, sample_domain=None):
         # thus there's no need to perform any transformations
         if X_source.shape[0] > 0:
             X_source = self.ot_transport_.transform(Xs=X_source)
-        X_adapt = _merge_source_target(X_source, X_target, sample_domain)
+        X_adapt, _ = source_target_merge(
+            X_source, X_target, sample_domain=sample_domain
+        )
         return X_adapt
 
     @abstractmethod
@@ -648,7 +650,9 @@ def adapt(self, X, y=None, sample_domain=None):
 
         X_source_adapt = np.dot(X_source, self.cov_source_inv_sqrt_)
         X_source_adapt = np.dot(X_source_adapt, self.cov_target_sqrt_)
-        X_adapt = _merge_source_target(X_source_adapt, X_target, sample_domain)
+        X_adapt, _ = source_target_merge(
+            X_source_adapt, X_target, sample_domain=sample_domain
+        )
         return X_adapt
 
 

skada/_subspace.py

@@ -13,7 +13,7 @@
 
 from .base import BaseAdapter
 from .utils import check_X_domain, source_target_split
-from ._utils import _merge_source_target
+from .utils import source_target_merge
 from ._pipeline import make_da_pipeline
 
 
@@ -93,7 +93,9 @@ def adapt(self, X, y=None, sample_domain=None, **kwargs):
         if X_target.shape[0]:
             X_target = np.dot(self.pca_target_.transform(X_target), self.M_)
         # xxx(okachaiev): this could be done through a more high-level API
-        X_adapt = _merge_source_target(X_source, X_target, sample_domain)
+        X_adapt, _ = source_target_merge(
+            X_source, X_target, sample_domain=sample_domain
+        )
         return X_adapt
 
     def fit(self, X, y=None, sample_domain=None, **kwargs):

skada/_utils.py

@@ -47,18 +47,6 @@ def _estimate_covariance(X, shrinkage):
     return s
 
 
-def _merge_source_target(X_source, X_target, sample_domain) -> np.ndarray:
-    n_samples = X_source.shape[0] + X_target.shape[0]
-    assert n_samples > 0
-    if X_source.shape[0] > 0:
-        output = np.zeros((n_samples, X_source.shape[1]), dtype=X_source.dtype)
-        output[sample_domain >= 0] = X_source
-    else:
-        output = np.zeros((n_samples, X_target.shape[1]), dtype=X_target.dtype)
-    output[sample_domain < 0] = X_target
-    return output
-
-
 def _check_y_masking(y):
     """Check that labels are properly masked
     ie. labels are either -1 or >= 0

skada/tests/test_utils.py

@@ -6,12 +6,16 @@
 
 import numpy as np
 
-from skada.datasets import make_dataset_from_moons_distribution
+from skada.datasets import (
+    make_dataset_from_moons_distribution
+)
 from skada.utils import (
-    check_X_domain,
     check_X_y_domain,
+    check_X_domain,
     extract_source_indices,
-    source_target_split
+    source_target_split,
+    source_target_merge
+
 )
 from skada._utils import _check_y_masking
 
@@ -290,3 +294,127 @@ def test_extract_source_indices():
     assert len(source_idx) == (len(sample_domain)), "source_idx shape mismatch"
     assert np.sum(source_idx) == 2 * n_samples_source, "source_idx sum mismatch"
     assert np.sum(~source_idx) == 2 * n_samples_target, "target_idx sum mismatch"
+
+
+def test_source_target_merge():
+    n_samples_source = 50
+    n_samples_target = 20
+    X, y, sample_domain = make_dataset_from_moons_distribution(
+        pos_source=0.1,
+        pos_target=0.9,
+        n_samples_source=n_samples_source,
+        n_samples_target=n_samples_target,
+        random_state=0,
+        return_X_y=True,
+    )
+
+    X_source, X_target, y_source, y_target = source_target_split(
+        X, y, sample_domain=sample_domain
+    )
+
+    # Test that no Error is raised for a 2D array
+    samples, _ = source_target_merge(X_source, X_target, sample_domain=sample_domain)
+    assert (
+        samples.shape[0] == X_source.shape[0] + X_target.shape[0]
+    ), "target_samples shape mismatch"
+
+    # Test that no Error is raised for a 1D array
+    labels, _ = source_target_merge(y_source, y_target, sample_domain=sample_domain)
+    assert (
+        labels.shape[0] == y_source.shape[0] + y_target.shape[0]
+    ), "labels shape mismatch"
+
+    # Test with empty samples
+    with pytest.raises(ValueError,
+                       match="Only one array can be None or empty in each pair"
+                       ):
+        _ = source_target_merge(np.array([]), np.array([]), sample_domain=np.array([]))
+
+    # Test that no Error with one empty sample
+    _ = source_target_merge(
+        X_source,
+        np.array([]),
+        sample_domain=np.array([1]*X_source.shape[0])
+    )
+    _ = source_target_merge(
+        np.array([]),
+        X_target,
+        sample_domain=np.array([-1]*X_target.shape[0])
+    )
+
+    # Test consistent length
+    with pytest.raises(ValueError,
+                       match="Inconsistent number of samples in source-target arrays "
+                       "and the number infered in the sample_domain"
+                       ):
+        _ = source_target_merge(X_source[0], X_target[1], sample_domain=sample_domain)
+
+    # Test no sample domain
+    _ = source_target_merge(X_source, X_target, sample_domain=None)
+
+    # Test odd number of array
+    with pytest.raises(ValueError,
+                       match="Even number of arrays required as input"
+                       ):
+        _ = source_target_merge(
+            X_source,
+            X_target,
+            y_source,
+            sample_domain=sample_domain
+        )
+
+    # Test >2 arrays
+    _ = source_target_merge(
+        X_source,
+        X_target,
+        y_source,
+        y_target,
+        sample_domain=sample_domain
+    )
+
+    # Test one array
+    with pytest.raises(ValueError,
+                       match="At least two array required as input"
+                       ):
+        _ = source_target_merge(X_source, sample_domain=sample_domain)
+
+    # Test y_target = None + Inconsistent number of samples in source-target
+    with pytest.raises(ValueError,
+                       match="Inconsistent number of samples in source-target arrays "
+                       "and the number infered in the sample_domain"
+                       ):
+        _ = source_target_merge(
+            X_source,
+            X_target,
+            np.ones_like(sample_domain),
+            None,
+            sample_domain=sample_domain
+        )
+
+    # Test y_target = None + Consistent number of samples in source-target
+    _ = source_target_merge(
+        X_source,
+        X_target,
+        y_source,
+        None,
+        sample_domain=sample_domain
+    )
+
+    # Test 2 None in a pair of arrays
+    with pytest.raises(ValueError,
+                       match="Only one array can be None or empty in each pair"
+                       ):
+        _ = source_target_merge(None, None, sample_domain=sample_domain)
+
+    # Test 1 None in 2 pair of arrays
+    _ = source_target_merge(X_source, None, y_source, None, sample_domain=sample_domain)
+
+    # Test inconsistent number of features
+    with pytest.raises(ValueError,
+                       match="Inconsistent number of features in source-target arrays"
+                       ):
+        _ = source_target_merge(
+            X_source[:, :-1],
+            X_target,
+            sample_domain=sample_domain
+        )