From 34a1341d732bf0c5875565638a52278970c4b8f2 Mon Sep 17 00:00:00 2001 From: Guillaume VIGNAL Date: Fri, 28 Aug 2026 17:01:57 +0200 Subject: [PATCH] Add contribution-weighted correlation plot --- .pre-commit-config.yaml | 7 +- shapash/explainer/smart_plotter.py | 86 +- shapash/manipulation/summarize.py | 193 +++- shapash/plots/plot_correlations.py | 319 +++++-- shapash/plots/plot_univariate.py | 4 +- .../explainer/test_smart_plotter.py | 46 + .../unit_tests/manipulation/test_summarize.py | 67 +- ...ot07-additional_plots_visualizations.ipynb | 867 ++++++++++++++++-- 8 files changed, 1403 insertions(+), 186 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4ab596c5..084a0f94 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -40,10 +40,9 @@ repos: hooks: - id: mypy name: mypy - # Runs from the local dev venv (not an isolated pre-commit env) so it sees - # shapash's actual dependencies. Path is explicit (not just `mypy`) so it - # also works from GUI clients like VSCode, whose PATH isn't venv-activated. - entry: .venv/bin/mypy shapash + # Runs from the local environment (not an isolated pre-commit env) so it sees + # shapash's actual dependencies. + entry: mypy shapash language: system pass_filenames: false files: ^shapash/.*\.py$ diff --git a/shapash/explainer/smart_plotter.py b/shapash/explainer/smart_plotter.py index 6a8e22a8..579261fd 100644 --- a/shapash/explainer/smart_plotter.py +++ b/shapash/explainer/smart_plotter.py @@ -16,7 +16,7 @@ from shapash.plots import plot_compacity from shapash.plots.plot_bar_chart import plot_bar_chart from shapash.plots.plot_contribution import plot_scatter, plot_violin -from shapash.plots.plot_correlations import plot_correlations +from shapash.plots.plot_correlations import plot_contributions_correlations, plot_correlations from shapash.plots.plot_evaluation_metrics import ( compute_kmeans_labels, compute_tsne_projection, @@ -1454,6 +1454,86 @@ def correlations_plot( return fig + def contributions_correlations_plot( + self, + df=None, + label=None, + optimized=False, + max_features=20, + features_to_hide=None, + facet_col=None, + width=900, + height=500, + degree=2.5, + decimals=2, + file_name=None, + auto_open=False, + ): + """ + Contribution-weighted correlations matrix heatmap plot. + + Parameters + ---------- + df : pd.DataFrame, optional + DataFrame used for faceting when `facet_col` is provided. Will use x_init by default. + label : int or str, optional + Label to select in classification mode. If omitted, the first label is used. + optimized : boolean, optional + True if we want to potentially accelerate the computation by reducing the number of rows. + max_features : int (default: 10) + Max number of features to show on the matrix. + features_to_hide : list (optional) + List of features that will not appear on the graph. + facet_col : str (optional) + Name of the column used to split the graph in two (or more) plots. + width : Int (default: 900) + Plotly figure - layout width + height : Int (default: 600) + Plotly figure - layout height + degree : int, optional, (default 2.5) + degree applied on the correlation matrix in order to focus more or less the clustering + on strong correlated variables + decimals : int, optional, (default 2) + number of decimals to plot for correlation values + file_name: string (optional) + File name to use to save the plotly bar chart. If None the bar chart will not be saved. + auto_open: Boolean (optional) + Indicate whether to open the bar plot or not. + + Returns + ------- + go.Figure + """ + if df is None: + df = self._explainer.x_init.copy() + + if self._explainer._case == "classification": + if label is None: + label = 0 + label_num, _, _ = self._explainer.check_label_name(label) + contributions = self._explainer.contributions[label_num] + else: + contributions = self._explainer.contributions + + fig = plot_contributions_correlations( + contributions=contributions, + df=df, + style_dict=self._style_dict, + features_dict=self._explainer.features_dict, + optimized=optimized, + max_features=max_features, + features_to_hide=features_to_hide, + facet_col=facet_col, + width=width, + height=height, + degree=degree, + decimals=decimals, + file_name=file_name, + auto_open=auto_open, + ) + + return fig + def local_neighbors_plot(self, index, max_features=10, file_name=None, auto_open=False, height="auto", width=900): """ The Local_neighbors_plot has the main objective of increasing confidence \ @@ -2018,7 +2098,7 @@ def distribution_plot( height: int = 500, nb_cat_max: int = 7, nb_hue_max: int = 7, - cat_num_threshold: int = 200, + cat_num_threshold: int = 15, file_name=None, auto_open=False, ) -> go.Figure: @@ -2049,7 +2129,7 @@ def distribution_plot( nb_hue_max : int, optional, default=7 Maximum number of hue categories to display. Categories beyond this limit are grouped into a new 'Other' category. - cat_num_threshold : int, optional, default=200 + cat_num_threshold : int, optional, default=15 Threshold on the number of unique values used to decide whether a numeric series is treated as categorical or continuous. file_name : str, optional diff --git a/shapash/manipulation/summarize.py b/shapash/manipulation/summarize.py index 517a6d9e..eac75421 100644 --- a/shapash/manipulation/summarize.py +++ b/shapash/manipulation/summarize.py @@ -3,6 +3,7 @@ """ import warnings +from typing import Any, Literal import numpy as np import pandas as pd @@ -13,7 +14,7 @@ from shapash.utils.transform import get_features_transform_mapping -def summarize_el(dataframe, mask, prefix): +def summarize_el(dataframe: pd.DataFrame, mask: pd.DataFrame, prefix: str) -> pd.DataFrame: """ Compute a summarized Matrix. @@ -45,7 +46,7 @@ def summarize_el(dataframe, mask, prefix): return df_summarized_matrix -def compute_features_import(dataframe, norm=1): +def compute_features_import(dataframe: pd.DataFrame, norm: int | float = 1) -> pd.Series: """ Compute a relative features importance, sum of absolute values of the contributions for each @@ -66,7 +67,14 @@ def compute_features_import(dataframe, norm=1): return feat_imp / tot -def summarize(s_contrib, var_dict, x_sorted, mask, columns_dict, features_dict): +def summarize( + s_contrib: pd.DataFrame, + var_dict: pd.DataFrame, + x_sorted: pd.DataFrame, + mask: pd.DataFrame, + columns_dict: dict[Any, str], + features_dict: dict[str, str], +) -> pd.DataFrame: """ Compute the summarized contributions of features. @@ -105,7 +113,7 @@ def summarize(s_contrib, var_dict, x_sorted, mask, columns_dict, features_dict): return summary -def group_contributions(contributions, features_groups): +def group_contributions(contributions: pd.DataFrame, features_groups: dict[str, list[str]]) -> pd.DataFrame: """ Regroup contributions according to features_groups parameter @@ -123,8 +131,8 @@ def group_contributions(contributions, features_groups): """ new_contributions = contributions.copy() # Computing features groups that are the sum of their corresponding features contributions - for group_name in features_groups.keys(): - new_contributions[group_name] = new_contributions[features_groups[group_name]].sum(axis=1) + for group_name, grouped_features in features_groups.items(): + new_contributions[group_name] = new_contributions[grouped_features].sum(axis=1) # Dropping features that are part of the group of features for features_grouped in features_groups.values(): @@ -133,7 +141,15 @@ def group_contributions(contributions, features_groups): return new_contributions -def project_feature_values_1d(feature_values, col, x_init, x_encoded, preprocessing, features_dict, how="tsne"): +def project_feature_values_1d( + feature_values: pd.DataFrame, + col: str, + x_init: pd.DataFrame, + x_encoded: pd.DataFrame, + preprocessing: Any, + features_dict: dict[str, str] | None, + how: Literal["tsne", "dict_of_values"] = "tsne", +) -> pd.Series: """ Project feature values of a group of features in 1 dimension. If feature_values contains categorical features, use preprocessing to get @@ -192,6 +208,7 @@ def project_feature_values_1d(feature_values, col, x_init, x_encoded, preprocess feature_values = pd.Series(feature_values.iloc[:, 0], name=col, index=feature_values.index) elif how == "dict_of_values": + features_dict = features_dict or {} feature_values.columns = [features_dict.get(x, x) for x in feature_values.columns] feature_values = pd.Series( feature_values.apply(lambda x: x.to_dict(), axis=1), name=col, index=feature_values.index @@ -203,7 +220,7 @@ def project_feature_values_1d(feature_values, col, x_init, x_encoded, preprocess return feature_values -def compute_corr(df, compute_method): +def compute_corr(df: pd.DataFrame, compute_method: Literal["phik", "pearson"]) -> pd.DataFrame: """ Compute correlations between features of given dataframe. @@ -227,16 +244,21 @@ def compute_corr(df, compute_method): errors="warn", ) if phik is None: - return df.corr() + return df.corr(numeric_only=True) return phik.phik_matrix(df, verbose=False) elif compute_method == "pearson": - return df.corr() + return df.corr(numeric_only=True) else: raise NotImplementedError(f"Not implemented correlation method : {compute_method}") def create_grouped_features_values( - x_init, x_encoded, preprocessing, features_groups, features_dict, how="tsne" + x_init: pd.DataFrame, + x_encoded: pd.DataFrame, + preprocessing: Any, + features_groups: dict[str, list[str]], + features_dict: dict[str, str] | None, + how: Literal["tsne", "dict_of_values"] = "tsne", ) -> pd.DataFrame: """ Compute projections of groups of features using t-sne. @@ -262,10 +284,10 @@ def create_grouped_features_values( features values with projection used for groups of features """ df = x_init.copy() - for group in features_groups.keys(): - if not isinstance(features_groups[group], list): + for group, grouped_features in features_groups.items(): + if not isinstance(grouped_features, list): raise ValueError(f"features_groups[{group}] should be a list of features") - features_values = x_init[features_groups[group]] + features_values = x_init[grouped_features] df[group] = project_feature_values_1d( features_values, col=group, @@ -275,8 +297,149 @@ def create_grouped_features_values( features_dict=features_dict, how=how, ) - for f in features_groups[group]: + for f in grouped_features: if f in df.columns: df.drop(f, axis=1, inplace=True) return df + + +def contribution_weighted_corr(contrib_i: pd.Series, contrib_j: pd.Series) -> float: + """Compute a contribution-weighted correlation between two features. + + The correlation is a weighted Pearson correlation where each + observation is weighted using the maximum absolute contribution + of the two features: + + weight_k = max(abs(contrib_i_k), abs(contrib_j_k)) + + This gives more importance to observations where at least one + of the two features has a strong contribution to the prediction. + + Missing contribution values (NaN) are considered as zero contributions. + + Parameters + ---------- + contrib_i : pd.Series + Contribution values of the first feature, with shape (n_samples,). + contrib_j : pd.Series + Contribution values of the second feature, with shape (n_samples,). + + Returns + ------- + float + Contribution-weighted correlation between -1 and 1. + Returns 0 if the correlation cannot be computed because + at least one feature has no variation in its contribution values. + + Raises + ------ + ValueError + If inputs are not one-dimensional, have different lengths, + are empty, or contain infinite values. + """ + contrib_i_array = np.asarray(contrib_i, dtype=np.float64) + contrib_j_array = np.asarray(contrib_j, dtype=np.float64) + + if contrib_i_array.ndim != 1 or contrib_j_array.ndim != 1: + raise ValueError("Contribution values must be one-dimensional arrays.") + + if contrib_i_array.shape[0] != contrib_j_array.shape[0]: + raise ValueError("Contribution arrays must contain the same number of observations.") + + if contrib_i_array.size == 0: + raise ValueError("Contribution arrays must not be empty.") + + if np.any(np.isinf(contrib_i_array)) or np.any(np.isinf(contrib_j_array)): + raise ValueError("Contribution values must not contain infinite values.") + + # Missing contribution values are considered as zero contributions. + contrib_i_array = np.nan_to_num(contrib_i_array, nan=0.0) + contrib_j_array = np.nan_to_num(contrib_j_array, nan=0.0) + + # Give more importance to observations where at least one + # feature has a strong contribution. + weights = np.maximum(np.abs(contrib_i_array), np.abs(contrib_j_array)) + + weight_sum = float(np.sum(weights)) + + # Both features have zero contribution values for every observation. + if weight_sum == 0.0: + return 0.0 + + mean_i = float(np.average(contrib_i_array, weights=weights)) + mean_j = float(np.average(contrib_j_array, weights=weights)) + + centered_i = contrib_i_array - mean_i + centered_j = contrib_j_array - mean_j + + covariance = float(np.sum(weights * centered_i * centered_j)) + variance_i = float(np.sum(weights * centered_i**2)) + variance_j = float(np.sum(weights * centered_j**2)) + denominator = float(np.sqrt(variance_i * variance_j)) + + # At least one feature has no variation in its contribution values. + if denominator == 0.0: + return 0.0 + + return float(np.clip(covariance / denominator, -1.0, 1.0)) + + +def contribution_weighted_corr_matrix(contrib_values: pd.DataFrame) -> pd.DataFrame: + """Compute a contribution-weighted correlation matrix. + + For each pair of features, the correlation is computed using + `contribution_weighted_corr`. + + The resulting matrix is symmetric and its diagonal is set to 1. + + Missing contribution values (NaN) are considered as zero contributions. + + Parameters + ---------- + contrib_values : pd.DataFrame + Contribution values with shape (n_samples, n_features). + + Returns + ------- + pd.DataFrame + Symmetric contribution-weighted correlation matrix with shape + (n_features, n_features). + + Raises + ------ + ValueError + If contrib_values is not a non-empty two-dimensional array + or contains infinite values. + """ + contrib_array = np.asarray(contrib_values, dtype=np.float64) + + if contrib_array.ndim != 2: + raise ValueError("contrib_values must have shape (n_samples, n_features).") + + if contrib_array.shape[0] == 0: + raise ValueError("contrib_values must contain at least one observation.") + + if contrib_array.shape[1] == 0: + raise ValueError("contrib_values must contain at least one feature.") + + if np.any(np.isinf(contrib_array)): + raise ValueError("Contribution values must not contain infinite values.") + + # Missing contribution values are considered as zero contributions. + contrib_array = np.nan_to_num(contrib_array, nan=0.0) + + n_features = contrib_array.shape[1] + + # Initialize the matrix with 1 on the diagonal. + corr_matrix = np.eye(n_features, dtype=np.float64) + + # Only compute the upper triangular part of the matrix. + for i in range(n_features): + for j in range(i + 1, n_features): + corr = contribution_weighted_corr(contrib_array[:, i], contrib_array[:, j]) + + corr_matrix[i, j] = corr + corr_matrix[j, i] = corr + + return pd.DataFrame(corr_matrix, index=contrib_values.columns, columns=contrib_values.columns) diff --git a/shapash/plots/plot_correlations.py b/shapash/plots/plot_correlations.py index 7cf4f18f..592b6905 100644 --- a/shapash/plots/plot_correlations.py +++ b/shapash/plots/plot_correlations.py @@ -6,12 +6,81 @@ from plotly.subplots import make_subplots from scipy.spatial.distance import pdist -from shapash.manipulation.summarize import compute_corr +from shapash.manipulation.summarize import compute_corr, contribution_weighted_corr_matrix from shapash.style.style_utils import define_style, get_palette from shapash.utils.dtypes import text_like_columns from shapash.utils.utils import adjust_title_height, compute_top_correlations_features, suffix_duplicates +def _cluster_corr(corr, degree, inplace=False): + """ + Rearranges the correlation matrix, corr, so that groups of highly + correlated variables are next to eachother. + + Parameters + ---------- + corr : pandas.DataFrame or numpy.ndarray + a NxN correlation matrix + degree : int + degree applied on the correlation matrix in order to focus more or less the clustering + on strong correlated variables + inplace : bool, optional + to replace the original correlation matrix by the new one, by default False + + Returns + ------- + pandas.DataFrame or numpy.ndarray + a NxN correlation matrix with the columns and rows rearranged + """ + if corr.shape[0] < 2: + return corr + + pairwise_distances = pdist(np.abs(corr) ** degree) + + finite_mask = np.isfinite(pairwise_distances) + if not np.all(finite_mask): + max_valid = pairwise_distances[finite_mask].max() if np.any(finite_mask) else 0.0 + pairwise_distances[~finite_mask] = max_valid + + linkage = sch.linkage(pairwise_distances, method="complete") + cluster_distance_threshold = pairwise_distances.max() / 2 + idx_to_cluster_array = sch.fcluster(linkage, cluster_distance_threshold, criterion="distance") + idx = np.argsort(idx_to_cluster_array) + + if not inplace: + corr = corr.copy() + + if isinstance(corr, pd.DataFrame): + return corr.iloc[idx, :].T.iloc[idx, :] + + return corr[idx, :][:, idx] + + +def _prepare_corr_matrix(corr, max_features, degree): + top_features = compute_top_correlations_features(corr=corr, max_features=max_features) + corr = _cluster_corr(corr.loc[top_features, top_features], degree=degree) + list_features = [col for col in corr.columns if col in top_features] + + k = 12 + list_features_shorten = [ + x.replace(x[k + k // 2 : -k + k // 2], "...") if len(x) > 2 * k + 3 else x for x in list_features + ] + list_features_shorten = suffix_duplicates(list_features_shorten) + return corr, list_features, list_features_shorten + + +def _resolve_style_dict(style_dict, palette_name): + if style_dict: + style_dict_default = {} + keys = ["dict_title", "init_contrib_colorscale"] + if any(key not in style_dict for key in keys): + style_dict_default = define_style(get_palette(palette_name)) + style_dict_default.update(style_dict) + return style_dict_default + + return define_style(get_palette(palette_name)) + + def plot_correlations( df, style_dict: dict | None = None, @@ -76,80 +145,12 @@ def plot_correlations( >>> xpl.plot.correlations() """ - def cluster_corr(corr, degree, inplace=False): - """ - Rearranges the correlation matrix, corr, so that groups of highly - correlated variables are next to eachother - - Parameters - ---------- - corr : pandas.DataFrame or numpy.ndarray - a NxN correlation matrix - degree : int - degree applied on the correlation matrix in order to focus more or less the clustering - on strong correlated variables - inplace : bool, optional - to replace the original correlation matrix by the new one, by default False - - Returns - ------- - pandas.DataFrame or numpy.ndarray - a NxN correlation matrix with the columns and rows rearranged - """ - - if corr.shape[0] < 2: - return corr - # Compute pairwise distances based on transformed correlation matrix - pairwise_distances = pdist(np.abs(corr) ** degree) - - # Replace non-finite values (NaN, inf) with the maximum valid distance or 0 if all are invalid - finite_mask = np.isfinite(pairwise_distances) - if not np.all(finite_mask): - # Use the maximum of the valid distances as a fallback value - max_valid = pairwise_distances[finite_mask].max() if np.any(finite_mask) else 0.0 - pairwise_distances[~finite_mask] = max_valid - - # Perform hierarchical clustering - linkage = sch.linkage(pairwise_distances, method="complete") - - # Define threshold for cluster cutting (half of the maximum distance) - cluster_distance_threshold = pairwise_distances.max() / 2 - - # Assign cluster labels - idx_to_cluster_array = sch.fcluster(linkage, cluster_distance_threshold, criterion="distance") - idx = np.argsort(idx_to_cluster_array) - - if not inplace: - corr = corr.copy() - - if isinstance(corr, pd.DataFrame): - return corr.iloc[idx, :].T.iloc[idx, :] - - return corr[idx, :][:, idx] - # Function to compute correlation matrix and prepare top features def prepare_corr_matrix(df_subset): corr = compute_corr(df_subset.drop(features_to_hide, axis=1), compute_method) - top_features = compute_top_correlations_features(corr=corr, max_features=max_features) - corr = cluster_corr(corr.loc[top_features, top_features], degree=degree) - list_features = [col for col in corr.columns if col in top_features] - - # Shorten long feature names and handle duplicates - k = 12 - list_features_shorten = [ - x.replace(x[k + k // 2 : -k + k // 2], "...") if len(x) > 2 * k + 3 else x for x in list_features - ] - list_features_shorten = suffix_duplicates(list_features_shorten) - return corr, list_features, list_features_shorten + return _prepare_corr_matrix(corr=corr, max_features=max_features, degree=degree) - if style_dict: - style_dict_default = {} - keys = ["dict_title", "init_contrib_colorscale"] - if any(key not in style_dict for key in keys): - style_dict_default = define_style(get_palette(palette_name)) - style_dict_default.update(style_dict) - else: - style_dict_default = define_style(get_palette(palette_name)) + style_dict_default = _resolve_style_dict(style_dict=style_dict, palette_name=palette_name) if features_dict is None: features_dict = {} @@ -263,3 +264,179 @@ def prepare_corr_matrix(df_subset): plot(fig, filename=file_name, auto_open=auto_open) return fig + + +def plot_contributions_correlations( + contributions, + df=None, + style_dict: dict | None = None, + palette_name: str = "default", + features_dict=None, + optimized=False, + max_features=20, + features_to_hide=None, + facet_col=None, + width=900, + height=500, + degree=2.5, + decimals=2, + file_name=None, + auto_open=False, +): + """ + Contribution-weighted correlations matrix heatmap plot. + Correlations are computed from contribution values using + `contribution_weighted_corr_matrix`. + + Parameters + ---------- + contributions : pd.DataFrame + Contribution values used to compute the correlation matrix. + df : pd.DataFrame, optional + DataFrame used to facet the plot when `facet_col` is provided. + Must share the same index as `contributions`. + style_dict: dict + the different styles used in the different outputs of Shapash + palette_name : str, optional, default="default" + The name of the color palette to be used if `colors_dict` is not provided. + features_dict: dict (default: None) + Dictionary mapping technical feature names to domain names. + optimized : boolean, optional + True if we want to potentially accelerate the computation of the correlation matrix by reducing the + number of rows used to compute it. + max_features : int (default: 10) + Max number of features to show on the matrix. + features_to_hide : list (optional) + List of features that will not appear on the graph. + facet_col : str (optional) + Name of the column used to split the graph in two (or more) plots. One correlation + subplot will be computed for each value of this column. + width : Int (default: 900) + Plotly figure - layout width + height : Int (default: 600) + Plotly figure - layout height + degree : int, optional, (default 2.5) + degree applied on the correlation matrix in order to focus more or less the clustering + on strong correlated variables + decimals : int, optional, (default 2) + number of decimals to plot for correlation values + file_name: string (optional) + File name to use to save the plotly bar chart. If None the bar chart will not be saved. + auto_open: Boolean (optional) + Indicate whether to open the bar plot or not. + + Returns + ------- + go.Figure + """ + + def prepare_corr_matrix(contrib_subset): + corr = contribution_weighted_corr_matrix(contrib_subset.drop(contrib_features_to_hide, axis=1)) + return _prepare_corr_matrix(corr=corr, max_features=max_features, degree=degree) + + style_dict_default = _resolve_style_dict(style_dict=style_dict, palette_name=palette_name) + + if features_dict is None: + features_dict = {} + + if features_to_hide is None: + features_to_hide = [] + else: + features_to_hide = list(features_to_hide) + + contrib_features_to_hide = [feature for feature in features_to_hide if feature in contributions.columns] + + if df is None: + df = pd.DataFrame(index=contributions.index) + else: + if not contributions.index.isin(df.index).all(): + raise ValueError("df must contain the same index as contributions.") + df = df.loc[contributions.index].copy() + + if facet_col is not None and facet_col not in df.columns: + raise ValueError("facet_col must be a column of df.") + + if optimized and len(contributions) > 10000: + sampled_index = contributions.sample(n=10000, random_state=1).index + contributions = contributions.loc[sampled_index] + df = df.loc[sampled_index] + + hovertemplate = "%{text}
Correlation: %{z}" + + list_features = [] + if facet_col: + facet_col_values = sorted(df[facet_col].unique(), reverse=True) + fig = make_subplots( + rows=1, + cols=df[facet_col].nunique(), + subplot_titles=[t + " correlation" for t in facet_col_values], + horizontal_spacing=0.15, + ) + for i, col_v in enumerate(facet_col_values): + subset_index = df[df[facet_col] == col_v].index + corr, list_features, list_features_shorten = prepare_corr_matrix(contributions.loc[subset_index]) + + fig.add_trace( + go.Heatmap( + z=corr.loc[list_features, list_features].round(decimals).values, + x=list_features_shorten, + y=list_features_shorten, + coloraxis="coloraxis", + text=[ + [ + f"Feature 1: {features_dict.get(y, y)}
Feature 2: {features_dict.get(x, x)}" + for x in list_features + ] + for y in list_features + ], + hovertemplate=hovertemplate, + ), + row=1, + col=i + 1, + ) + else: + corr, list_features, list_features_shorten = prepare_corr_matrix(contributions) + + fig = go.Figure( + go.Heatmap( + z=corr.loc[list_features, list_features].round(decimals).values, + x=list_features_shorten, + y=list_features_shorten, + coloraxis="coloraxis", + text=[ + [ + f"Feature 1: {features_dict.get(y, y)}
Feature 2: {features_dict.get(x, x)}" + for x in list_features + ] + for y in list_features + ], + hovertemplate=hovertemplate, + ) + ) + + title = "Correlation (contribution-weighted)" + if len(list_features) < len(contributions.drop(contrib_features_to_hide, axis=1).columns): + subtitle = f"Top {len(list_features)} correlations" + title += f"
{subtitle}" + dict_t = style_dict_default["dict_title"] | {"text": title, "y": adjust_title_height(height)} + + if corr.min().min() >= 0: + colorscale = ["rgb(255, 255, 255)"] + style_dict_default["init_contrib_colorscale"][5:-1] + else: + colorscale = style_dict_default["init_contrib_colorscale"] + + fig.update_layout( + coloraxis=dict(colorscale=colorscale), + showlegend=True, + title=dict_t, + width=width, + height=height, + ) + + fig.update_yaxes(automargin=True) + fig.update_xaxes(automargin=True) + + if file_name: + plot(fig, filename=file_name, auto_open=auto_open) + + return fig diff --git a/shapash/plots/plot_univariate.py b/shapash/plots/plot_univariate.py index f4c9c0c4..db7b4941 100644 --- a/shapash/plots/plot_univariate.py +++ b/shapash/plots/plot_univariate.py @@ -21,7 +21,7 @@ def plot_distribution( palette_name: str = "default", nb_cat_max: int = 7, nb_hue_max: int = 7, - cat_num_threshold: int = 200, + cat_num_threshold: int = 15, file_name=None, auto_open=False, ) -> go.Figure: @@ -59,7 +59,7 @@ def plot_distribution( nb_hue_max : int, optional, default=7 Maximum number of hue categories to display. Categories beyond this limit are grouped into a new 'Other' category. - cat_num_threshold : int, optional, default=200 + cat_num_threshold : int, optional, default=15 Threshold on the number of unique values used to decide whether a numeric series is treated as categorical or continuous. file_name : str, optional diff --git a/tests/unit_tests/explainer/test_smart_plotter.py b/tests/unit_tests/explainer/test_smart_plotter.py index b6c22eb6..5d1e8fb2 100644 --- a/tests/unit_tests/explainer/test_smart_plotter.py +++ b/tests/unit_tests/explainer/test_smart_plotter.py @@ -2134,6 +2134,52 @@ def test_correlations_does_not_mutate_features_to_hide(self): assert len(output.data) == 2 assert features_to_hide == ["D"] + def test_contributions_correlations_1(self): + """ + Test contribution-weighted correlations plot 1 + """ + smart_explainer = self.smart_explainer + + output = smart_explainer.plot.contributions_correlations_plot(label=0, max_features=2) + + assert len(output.data) == 1 + assert len(output.data[0].x) == 2 + assert len(output.data[0].y) == 2 + assert output.data[0].z.shape == (2, 2) + + def test_contributions_correlations_2(self): + """ + Test contribution-weighted correlations plot 2 + """ + smart_explainer = self.smart_explainer + + df = pd.DataFrame( + {"C": ["C8", "C9"]}, + index=["person_A", "person_B"], + ) + + output = smart_explainer.plot.contributions_correlations_plot(df=df, label=0, max_features=2, facet_col="C") + + assert len(output.data) == 2 + assert len(output.data[0].x) == 2 + assert len(output.data[0].y) == 2 + assert output.data[0].z.shape == (2, 2) + + def test_contributions_correlations_does_not_mutate_features_to_hide(self): + smart_explainer = self.smart_explainer + features_to_hide = ["X2"] + + output = smart_explainer.plot.contributions_correlations_plot( + df=pd.DataFrame({"C": ["C8", "C9"]}, index=["person_A", "person_B"]), + label=0, + max_features=2, + features_to_hide=features_to_hide, + facet_col="C", + ) + + assert len(output.data) == 2 + assert features_to_hide == ["X2"] + def test_stability_plot_1(self): np.random.seed(42) df = pd.DataFrame(np.random.randint(0, 100, size=(50, 4)), columns=list("ABCD")) diff --git a/tests/unit_tests/manipulation/test_summarize.py b/tests/unit_tests/manipulation/test_summarize.py index f2fcd169..75dab75f 100644 --- a/tests/unit_tests/manipulation/test_summarize.py +++ b/tests/unit_tests/manipulation/test_summarize.py @@ -8,7 +8,14 @@ import pandas as pd from pandas.testing import assert_frame_equal -from shapash.manipulation.summarize import compute_corr, compute_features_import, group_contributions, summarize_el +from shapash.manipulation.summarize import ( + contribution_weighted_corr, + contribution_weighted_corr_matrix, + compute_corr, + compute_features_import, + group_contributions, + summarize_el, +) class TestSummarize(unittest.TestCase): @@ -156,3 +163,61 @@ def test_compute_corr_phik_fallback_to_pearson_when_not_installed(self): def test_compute_corr_unknown_method_raises(self): with self.assertRaises(NotImplementedError): compute_corr(self.df, "spearman") + + +class TestContributionWeightedCorr(unittest.TestCase): + def test_contribution_weighted_corr_perfect_positive_corr(self): + result = contribution_weighted_corr(pd.Series([1.0, 2.0, 3.0]), pd.Series([2.0, 4.0, 6.0])) + assert np.isclose(result, 1.0) + + def test_contribution_weighted_corr_treats_nan_as_zero(self): + result = contribution_weighted_corr(pd.Series([1.0, np.nan, -1.0]), pd.Series([2.0, 0.0, -2.0])) + assert np.isclose(result, 1.0) + + def test_contribution_weighted_corr_returns_zero_without_variation(self): + result = contribution_weighted_corr(pd.Series([0.0, 0.0, 0.0]), pd.Series([1.0, -1.0, 2.0])) + assert result == 0.0 + + def test_contribution_weighted_corr_raises_on_invalid_input(self): + with self.assertRaises(ValueError): + contribution_weighted_corr([[1.0], [2.0]], [1.0, 2.0]) + + with self.assertRaises(ValueError): + contribution_weighted_corr([1.0, 2.0], [1.0]) + + with self.assertRaises(ValueError): + contribution_weighted_corr([1.0, np.inf], [1.0, 2.0]) + + +class TestContributionWeightedCorrMatrix(unittest.TestCase): + def test_contribution_weighted_corr_matrix_is_symmetric(self): + contrib_values = pd.DataFrame( + { + "feature_1": [1.0, 2.0, 3.0], + "feature_2": [2.0, 4.0, 6.0], + "feature_3": [-1.0, 0.0, 1.0], + } + ) + + result = contribution_weighted_corr_matrix(contrib_values) + + assert result.shape == (3, 3) + assert list(result.index) == list(contrib_values.columns) + assert list(result.columns) == list(contrib_values.columns) + assert np.allclose(np.diag(result), 1.0) + assert np.allclose(result, result.T) + assert np.isclose(result.loc["feature_1", "feature_2"], 1.0) + assert np.isclose( + result.loc["feature_1", "feature_3"], + contribution_weighted_corr(contrib_values["feature_1"], contrib_values["feature_3"]), + ) + + def test_contribution_weighted_corr_matrix_raises_on_invalid_input(self): + with self.assertRaises(ValueError): + contribution_weighted_corr_matrix([1.0, 2.0, 3.0]) + + with self.assertRaises(ValueError): + contribution_weighted_corr_matrix(np.empty((0, 2))) + + with self.assertRaises(ValueError): + contribution_weighted_corr_matrix(np.array([[1.0, np.inf]])) diff --git a/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb b/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb index 46e53290..cd5913aa 100644 --- a/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb +++ b/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -43,6 +43,127 @@ "outputs": [ { "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "PassengerId", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Survived", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Pclass", + "rawType": "str", + "type": "string" + }, + { + "name": "Sex", + "rawType": "str", + "type": "string" + }, + { + "name": "Age", + "rawType": "float64", + "type": "float" + }, + { + "name": "SibSp", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Parch", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Fare", + "rawType": "float64", + "type": "float" + }, + { + "name": "Embarked", + "rawType": "str", + "type": "string" + }, + { + "name": "Title", + "rawType": "str", + "type": "string" + } + ], + "ref": "1a101598-05f7-4d54-b572-f1a8d1098f90", + "rows": [ + [ + "1", + "0", + "Third class", + "male", + "22.0", + "1", + "0", + "7.25", + "Southampton", + "Mr" + ], + [ + "2", + "1", + "First class", + "female", + "38.0", + "1", + "0", + "71.28", + "Cherbourg", + "Mrs" + ], + [ + "3", + "1", + "Third class", + "female", + "26.0", + "0", + "0", + "7.92", + "Southampton", + "Miss" + ], + [ + "4", + "1", + "First class", + "female", + "35.0", + "1", + "0", + "53.1", + "Southampton", + "Mrs" + ], + [ + "5", + "0", + "Third class", + "male", + "35.0", + "0", + "0", + "8.05", + "Southampton", + "Mr" + ] + ], + "shape": { + "columns": 9, + "rows": 5 + } + }, "text/html": [ "
\n", "
ExtraTreesClassifier(n_estimators=200, random_state=7)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "\n", + ".estimator-table {\n", + " font-family: monospace;\n", + "}\n", + "\n", + ".estimator-table summary {\n", + " padding: .5rem;\n", + " cursor: pointer;\n", + "}\n", + "\n", + ".estimator-table summary::marker {\n", + " font-size: 0.7rem;\n", + "}\n", + "\n", + ".estimator-table details[open] {\n", + " padding-left: 0.1rem;\n", + " padding-right: 0.1rem;\n", + " padding-bottom: 0.3rem;\n", + "}\n", + "\n", + ".estimator-table .parameters-table {\n", + " margin-left: auto !important;\n", + " margin-right: auto !important;\n", + " margin-top: 0;\n", + "}\n", + "\n", + ".estimator-table .parameters-table tr:nth-child(odd) {\n", + " background-color: #fff;\n", + "}\n", + "\n", + ".estimator-table .parameters-table tr:nth-child(even) {\n", + " background-color: #f6f6f6;\n", + "}\n", + "\n", + ".estimator-table .parameters-table tr:hover {\n", + " background-color: #e0e0e0;\n", + "}\n", + "\n", + ".estimator-table table td {\n", + " border: 1px solid rgba(106, 105, 104, 0.232);\n", + "}\n", + "\n", + "/*\n", + " `table td`is set in notebook with right text-align.\n", + " We need to overwrite it.\n", + "*/\n", + ".estimator-table table td.param {\n", + " text-align: left;\n", + " position: relative;\n", + " padding: 0;\n", + "}\n", + "\n", + ".user-set td {\n", + " color:rgb(255, 94, 0);\n", + " text-align: left !important;\n", + "}\n", + "\n", + ".user-set td.value {\n", + " color:rgb(255, 94, 0);\n", + " background-color: transparent;\n", + "}\n", + "\n", + ".default td {\n", + " color: black;\n", + " text-align: left !important;\n", + "}\n", + "\n", + ".user-set td i,\n", + ".default td i {\n", + " color: black;\n", + "}\n", + "\n", + "/*\n", + " Styles for parameter documentation links\n", + " We need styling for visited so jupyter doesn't overwrite it\n", + "*/\n", + "a.param-doc-link,\n", + "a.param-doc-link:link,\n", + "a.param-doc-link:visited {\n", + " text-decoration: underline dashed;\n", + " text-underline-offset: .3em;\n", + " color: inherit;\n", + " display: block;\n", + " padding: .5em;\n", + "}\n", + "\n", + "/* \"hack\" to make the entire area of the cell containing the link clickable */\n", + "a.param-doc-link::before {\n", + " position: absolute;\n", + " content: \"\";\n", + " inset: 0;\n", + "}\n", + "\n", + ".param-doc-description {\n", + " display: none;\n", + " position: absolute;\n", + " z-index: 9999;\n", + " left: 0;\n", + " padding: .5ex;\n", + " margin-left: 1.5em;\n", + " color: var(--sklearn-color-text);\n", + " box-shadow: .3em .3em .4em #999;\n", + " width: max-content;\n", + " text-align: left;\n", + " max-height: 10em;\n", + " overflow-y: auto;\n", + "\n", + " /* unfitted */\n", + " background: var(--sklearn-color-unfitted-level-0);\n", + " border: thin solid var(--sklearn-color-unfitted-level-3);\n", + "}\n", + "\n", + "/* Fitted state for parameter tooltips */\n", + ".fitted .param-doc-description {\n", + " /* fitted */\n", + " background: var(--sklearn-color-fitted-level-0);\n", + " border: thin solid var(--sklearn-color-fitted-level-3);\n", + "}\n", + "\n", + ".param-doc-link:hover .param-doc-description {\n", + " display: block;\n", + "}\n", + "\n", + ".copy-paste-icon {\n", + " background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);\n", + " background-repeat: no-repeat;\n", + " background-size: 14px 14px;\n", + " background-position: 0;\n", + " display: inline-block;\n", + " width: 14px;\n", + " height: 14px;\n", + " cursor: pointer;\n", + "}\n", + "
ExtraTreesClassifier(n_estimators=200, random_state=7)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "ExtraTreesClassifier(n_estimators=200, random_state=7)" @@ -756,7 +1440,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "INFO: Shap explainer type - \n" + "INFO: Shap explainer type - \n" ] } ], @@ -779,24 +1463,26 @@ "source": [ "## Visualization\n", "\n", - "We can conveniently display the previous plots for the test set and the confusion matrix using built-in functions." + "\n", + "\n", + "We can conveniently display the previous plots for the test set and the confusion matrix using built-in functions.\n", + "\n", + "\n", + "\n", + "The first heatmap is computed from the dataset values, while the second one is computed from the feature contributions produced by the explainer.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "" - ] + "image/png": "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" }, - "execution_count": 9, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -805,19 +1491,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "" - ] + "image/png": "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" }, - "execution_count": 10, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + } + ], + "source": [ + "xpl.plot.contributions_correlations_plot(label=0, width=500, height=450)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -827,19 +1526,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "" - ] + "image/png": "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" }, - "execution_count": 11, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -857,19 +1552,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "" - ] + "image/png": "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" }, - "execution_count": 12, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -890,19 +1581,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "" - ] + "image/png": "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" }, - "execution_count": 13, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -917,7 +1604,7 @@ ], "metadata": { "kernelspec": { - "display_name": "keltarif_39", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -931,7 +1618,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.18" + "version": "3.12.12" } }, "nbformat": 4,