fix: move pattern based metrics from missing_patterns to metrics

Author: anhkhoangoho

qolmat/benchmark/comparator.py

@@ -41,7 +41,9 @@ class Comparator:
         "pairwise_dist": metrics.sum_pairwise_distances,
         "energy": metrics.sum_energy_distances,
         "frechet": metrics.frechet_distance,
-        "correlation_dist": partial(metrics.distance_correlation_complement),
+        "dist_corr_pattern": partial(
+            metrics.pattern_based_metric, metric=metrics.distance_correlation_complement
+        ),
     }
 
     def __init__(

qolmat/benchmark/metrics.py

@@ -1,4 +1,4 @@
-from typing import Callable, List, Optional
+from typing import Callable, List, Optional, Dict
 
 import numpy as np
 import pandas as pd
@@ -854,10 +854,62 @@ def distance_correlation_complement(
     pd.Series
         Correlation distance
     """
-    df1[~df_mask] = np.nan
-    df2[~df_mask] = np.nan
-
-    df1 = df1.dropna(axis=0, how="all").dropna(axis=1, how="any")
-    df2 = df2.dropna(axis=0, how="all").dropna(axis=1, how="any")
+    # For the case that we use this function outside pattern_based_metric
+    df1 = df1[df_mask].fillna(0.0)
+    df2 = df2[df_mask].fillna(0.0)
 
     return 1.0 - pd.Series(dcor.distance_correlation(df1.values, df2.values), index=["All"])
+
+
+def pattern_based_metric(
+    df1: pd.DataFrame,
+    df2: pd.DataFrame,
+    df_mask: pd.DataFrame,
+    metric: Callable,
+    min_num_row: int = 10,
+    **kwargs,
+) -> pd.Series:
+    """_summary_
+
+    Parameters
+    ----------
+    df1 : pd.DataFrame
+        true dataframe
+    df2 : pd.DataFrame
+        predicted dataframe
+    df_mask : pd.DataFrame
+        Elements of the dataframes to compute on
+    metric : Callable
+        metric function
+    min_num_row : int, optional
+        minimum number of row allowed for a pattern without nan, by default 10
+
+    Returns
+    -------
+    pd.Series
+        _description_
+    """
+    # Identify all distinct missing data patterns
+    z = 1 + np.log(1 + np.arange(df_mask.shape[1]))
+    c = np.dot(df_mask, z)
+    row_map: Dict = {}
+    for i, v in enumerate(c):
+        if v == 0:
+            # No missing values
+            continue
+        if v not in row_map:
+            row_map[v] = []
+        row_map[v].append(i)
+    patterns = [np.asarray(v) for v in row_map.values()]
+    scores = []
+    for pattern in patterns:
+        df1_pattern = df1.iloc[pattern].dropna(axis=1)
+        if len(df1_pattern.columns) == 0:
+            df1_pattern = df1.iloc[pattern].dropna(axis=0)
+
+        if len(df1_pattern) >= min_num_row:
+            df2_pattern = df2.loc[df1_pattern.index, df1_pattern.columns]
+
+            scores.append(metric(df1_pattern, df2_pattern, ~df1_pattern.isna(), **kwargs))
+
+    return pd.Series(np.mean(scores), index=["All"])

qolmat/benchmark/missing_patterns.py

@@ -699,110 +699,3 @@ def split(self, X: pd.DataFrame) -> List[pd.DataFrame]:
             list_masks.append(df_mask)
 
         return list_masks
-
-
-class PatternHoleGenerator(_HoleGenerator):
-    """This class implements a way to generate holes in a dataframe.
-    The holes are generated from pattern, specified by the user.
-
-    Parameters
-    ----------
-    n_splits : int
-        Number of splits
-    subset : Optional[List[str]], optional
-        Names of the columns for which holes must be created, by default None
-    ratio_masked : Optional[float], optional
-        Ratio of masked values ​​to add, by default 0.05.
-    random_state : Optional[int], optional
-        The seed used by the random number generator, by default 42.
-    groups : List[str]
-        Names of the columns forming the groups, by default []
-    """
-
-    def __init__(
-        self,
-        n_splits: int,
-        ratio_masked: float = 0.05,
-        random_state: Union[None, int, np.random.RandomState] = None,
-        groups: List[str] = [],
-    ):
-        super().__init__(
-            n_splits=n_splits,
-            subset=None,
-            random_state=random_state,
-            ratio_masked=ratio_masked,
-            groups=groups,
-        )
-
-    def fit(self, X: pd.DataFrame) -> PatternHoleGenerator:
-        """Creare the groups based on the column names (groups attribute)
-
-        Parameters
-        ----------
-        X : pd.DataFrame
-
-        Returns
-        -------
-        PatternHoleGenerator
-            The model itself
-
-        Raises
-        ------
-        if the number of samples/splits is greater than the number of groups.
-        """
-
-        super().fit(X)
-        df_isna = X.isna().apply(lambda x: self.get_pattern(x), axis=1).to_frame(name="pattern")
-        self.df_isna = df_isna["pattern"]
-        self.patterns_counts = self.df_isna.value_counts()
-        patterns = self.patterns_counts.index.to_list()
-        if "_ALLNAN_" in patterns:
-            patterns.remove("_ALLNAN_")
-        if "_EMPTY_" in patterns:
-            patterns.remove("_EMPTY_")
-        self.patterns = patterns
-
-        return self
-
-    def generate_mask(self, X: pd.DataFrame) -> pd.DataFrame:
-        """
-        Returns a mask for the dataframe at hand.
-
-        Parameters
-        ----------
-        X : pd.DataFrame
-            Initial dataframe with a missing pattern to be imitated.
-        """
-        if self.ngroups is not None:
-            self.fit(X)
-
-        df_mask = pd.DataFrame(False, index=X.index, columns=X.columns)
-        patterns_selected = ["_EMPTY_"]
-        patterns = self.patterns
-        for k in range(len(self.patterns)):
-            pattern = random.choice(patterns)
-            patterns_selected_ = patterns_selected + [pattern]
-            patterns.remove(pattern)
-            df_mask_ = df_mask.copy()
-            X_ = X.copy()
-
-            df_mask_.loc[self.df_isna[self.df_isna.isin(patterns_selected_)].index] = True
-            X_[~df_mask_] = np.nan
-            X_ = X_.dropna(axis=0, how="all").dropna(axis=1, how="any")
-            if X_.size == 0:
-                break
-            patterns_selected.append(pattern)
-            if self.patterns_counts.loc[patterns_selected_].sum() / len(X) > self.ratio_masked:
-                break
-
-        df_mask.loc[self.df_isna[self.df_isna.isin(patterns_selected)].index] = True
-        return df_mask
-
-    def get_pattern(self, row: pd.Series) -> str:
-        list_col_pattern = [col for col in row.index.to_list() if row[col] == True]
-        if len(list_col_pattern) == 0:
-            return "_EMPTY_"
-        elif len(list_col_pattern) == row.index.size:
-            return "_ALLNAN_"
-        else:
-            return "__".join(list_col_pattern)