From 49a198c21ccdbf8a29ad4d642073a3317290a405 Mon Sep 17 00:00:00 2001 From: Guillaume VIGNAL Date: Thu, 21 Nov 2024 12:07:47 +0100 Subject: [PATCH 1/5] Refacto report plots --- shapash/plots/plot_metrics.py | 50 +++++++ .../plots.py => plots/plot_univariate.py} | 136 ++++++++++-------- shapash/report/project_report.py | 5 +- tests/unit_tests/report/test_plots.py | 2 +- 4 files changed, 131 insertions(+), 62 deletions(-) create mode 100644 shapash/plots/plot_metrics.py rename shapash/{report/plots.py => plots/plot_univariate.py} (56%) diff --git a/shapash/plots/plot_metrics.py b/shapash/plots/plot_metrics.py new file mode 100644 index 00000000..58d6f472 --- /dev/null +++ b/shapash/plots/plot_metrics.py @@ -0,0 +1,50 @@ +from typing import Optional, Union + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from matplotlib.colors import LinearSegmentedColormap + +from shapash.style.style_utils import get_palette, get_pyplot_color + + +def generate_confusion_matrix_plot( + y_true: Union[np.array, list], + y_pred: Union[np.array, list], + colors_dict: Optional[dict] = None, + width: int = 7, + height: int = 4, + palette_name: str = "default", +) -> plt.Figure: + """ + Returns a matplotlib figure containing a confusion matrix that is computed using y_true and + y_pred parameters. + + Parameters + ---------- + y_true : array-like + Ground truth (correct) target values. + y_pred : array-like + Estimated targets as returned by a classifier. + colors_dict : dict + dict of colors used + width : int, optional, default=7 + The width of the generated figure, in inches. + height : int, optional, default=4 + The height of the generated figure, in inches. + palette_name : str, optional, default="default" + The name of the color palette to be used if `colors_dict` is not provided. + + Returns + ------- + matplotlib.pyplot.Figure + """ + colors_dict = colors_dict or get_palette(palette_name) + col_scale = get_pyplot_color(colors=colors_dict["report_confusion_matrix"]) + cmap_gradient = LinearSegmentedColormap.from_list("col_corr", col_scale, N=100) + + df_cm = pd.crosstab(y_true, y_pred, rownames=["Actual"], colnames=["Predicted"]) + fig, ax = plt.subplots(figsize=(width, height)) + sns.heatmap(df_cm, ax=ax, annot=True, cmap=cmap_gradient, fmt="g") + return fig diff --git a/shapash/report/plots.py b/shapash/plots/plot_univariate.py similarity index 56% rename from shapash/report/plots.py rename to shapash/plots/plot_univariate.py index 0f06bcbe..88c658d3 100644 --- a/shapash/report/plots.py +++ b/shapash/plots/plot_univariate.py @@ -1,10 +1,9 @@ -from typing import Optional, Union +from typing import Optional import matplotlib.pyplot as plt import numpy as np import pandas as pd import seaborn as sns -from matplotlib.colors import LinearSegmentedColormap from shapash.report.common import VarType from shapash.style.style_utils import get_palette, get_pyplot_color @@ -12,47 +11,72 @@ def generate_fig_univariate( - df_all: pd.DataFrame, col: str, hue: str, type: VarType, colors_dict: Optional[dict] = None + df_all: pd.DataFrame, + col: str, + hue: str, + serie_type: VarType, + colors_dict: Optional[dict] = None, + width: int = 7, + height: int = 4, + palette_name: str = "default", ) -> plt.Figure: """ - Returns a matplotlib figure containing the distribution of any kind of feature - (continuous, categorical). + Generate a matplotlib figure displaying the univariate distribution of a feature + (continuous or categorical) in the dataset. - If the feature is categorical and contains too many categories, the smallest - categories are grouped into a new 'Other' category so that the graph remains - readable. + For categorical features with too many unique categories, the least frequent + categories are grouped into a new 'Other' category to ensure the plot remains + readable. Continuous features are visualized using histograms. - The input dataframe should contain the column of interest and a column that is used - to distinguish two types of values (ex. 'train' and 'test') + The input DataFrame must contain the column of interest (`col`) and a second column + (`hue`) used to distinguish between two groups (e.g., 'train' and 'test'). Parameters ---------- df_all : pd.DataFrame - The input dataframe that contains the column of interest + The input DataFrame containing the data to be plotted. col : str - The column of interest + The name of the column of interest whose distribution is to be visualized. hue : str - The column used to distinguish the values (ex. 'train' and 'test') - type: str - The type of the series ('continous' or 'categorical') - colors_dict : dict - dict of colors used + The name of the column used to differentiate between groups (e.g., 'train' and 'test'). + serie_type : VarType + The type of the feature, either 'continuous' or 'categorical'. + colors_dict : dict, optional + A dictionary specifying the colors to be used for each group. If not provided, + a default color palette will be used. + width : int, optional, default=7 + The width of the generated figure, in inches. + height : int, optional, default=4 + The height of the generated figure, in inches. + palette_name : str, optional, default="default" + The name of the color palette to be used if `colors_dict` is not provided. Returns ------- matplotlib.pyplot.Figure + A matplotlib figure object representing the distribution of the feature. """ - if type == VarType.TYPE_NUM: - fig = generate_fig_univariate_continuous(df_all, col, hue=hue, colors_dict=colors_dict) - elif type == VarType.TYPE_CAT: - fig = generate_fig_univariate_categorical(df_all, col, hue=hue, colors_dict=colors_dict) + if serie_type == VarType.TYPE_NUM: + fig = generate_fig_univariate_continuous( + df_all, col, hue=hue, colors_dict=colors_dict, width=width, height=height, palette_name=palette_name + ) + elif serie_type == VarType.TYPE_CAT: + fig = generate_fig_univariate_categorical( + df_all, col, hue=hue, colors_dict=colors_dict, width=width, height=height, palette_name=palette_name + ) else: raise NotImplementedError("Series dtype not supported") return fig def generate_fig_univariate_continuous( - df_all: pd.DataFrame, col: str, hue: str, colors_dict: Optional[dict] = None + df_all: pd.DataFrame, + col: str, + hue: str, + colors_dict: Optional[dict] = None, + width: int = 7, + height: int = 4, + palette_name: str = "default", ) -> plt.Figure: """ Returns a matplotlib figure containing the distribution of a continuous feature. @@ -67,14 +91,24 @@ def generate_fig_univariate_continuous( The column used to distinguish the values (ex. 'train' and 'test') colors_dict : dict dict of colors used + width : int, optional, default=7 + The width of the generated figure, in inches. + height : int, optional, default=4 + The height of the generated figure, in inches. + palette_name : str, optional, default="default" + The name of the color palette to be used if `colors_dict` is not provided. Returns ------- matplotlib.pyplot.Figure """ - colors_dict = colors_dict or get_palette("default") + colors_dict = colors_dict or get_palette(palette_name) + lower_quantile = df_all[:, col].quantile(0.005) + upper_quantile = df_all[:, col].quantile(0.995) + cond = (df_all[col] > lower_quantile) & (df_all[col] < upper_quantile) + g = sns.displot( - df_all, + df_all[cond], x=col, hue=hue, kind="kde", @@ -84,16 +118,23 @@ def generate_fig_univariate_continuous( ) g.set_xticklabels(rotation=30) - fig = g.fig + fig = g.figure - fig.set_figwidth(7) - fig.set_figheight(4) + fig.set_figwidth(width) + fig.set_figheight(height) return fig def generate_fig_univariate_categorical( - df_all: pd.DataFrame, col: str, hue: str, nb_cat_max: int = 7, colors_dict: Optional[dict] = None + df_all: pd.DataFrame, + col: str, + hue: str, + nb_cat_max: int = 7, + colors_dict: Optional[dict] = None, + width: int = 7, + height: int = 4, + palette_name: str = "default", ) -> plt.Figure: """ Returns a matplotlib figure containing the distribution of a categorical feature. @@ -116,12 +157,18 @@ def generate_fig_univariate_categorical( 'Other' category colors_dict : dict dict of colors used + width : int, optional, default=7 + The width of the generated figure, in inches. + height : int, optional, default=4 + The height of the generated figure, in inches. + palette_name : str, optional, default="default" + The name of the color palette to be used if `colors_dict` is not provided. Returns ------- matplotlib.pyplot.Figure """ - colors_dict = colors_dict or get_palette("default") + colors_dict = colors_dict or get_palette(palette_name) df_cat = df_all.groupby([col, hue]).agg({col: "count"}).rename(columns={col: "count"}).reset_index() df_cat["Percent"] = df_cat["count"] * 100 / df_cat.groupby(hue)["count"].transform("sum") @@ -134,7 +181,7 @@ def generate_fig_univariate_categorical( if nb_cat > nb_cat_max: df_cat = _merge_small_categories(df_cat=df_cat, col=col, hue=hue, nb_cat_max=nb_cat_max) - fig, ax = plt.subplots(figsize=(7, 4)) + fig, ax = plt.subplots(figsize=(width, height)) sns.barplot( data=df_cat, @@ -184,32 +231,3 @@ def _merge_small_categories(df_cat: pd.DataFrame, col: str, hue: str, nb_cat_max ) df_cat_other[col] = "Other" return pd.concat([df_cat.loc[~df_cat[col].isin(list_cat_to_merge)], df_cat_other], axis=0) - - -def generate_confusion_matrix_plot( - y_true: Union[np.array, list], y_pred: Union[np.array, list], colors_dict: Optional[dict] = None -) -> plt.Figure: - """ - Returns a matplotlib figure containing a confusion matrix that is computed using y_true and - y_pred parameters. - - Parameters - ---------- - y_true : array-like - Ground truth (correct) target values. - y_pred : array-like - Estimated targets as returned by a classifier. - colors_dict : dict - dict of colors used - Returns - ------- - matplotlib.pyplot.Figure - """ - colors_dict = colors_dict or get_palette("default") - col_scale = get_pyplot_color(colors=colors_dict["report_confusion_matrix"]) - cmap_gradient = LinearSegmentedColormap.from_list("col_corr", col_scale, N=100) - - df_cm = pd.crosstab(y_true, y_pred, rownames=["Actual"], colnames=["Predicted"]) - fig, ax = plt.subplots(figsize=(7, 4)) - sns.heatmap(df_cm, ax=ax, annot=True, cmap=cmap_gradient, fmt="g") - return fig diff --git a/shapash/report/project_report.py b/shapash/report/project_report.py index 6d098089..3b705f40 100644 --- a/shapash/report/project_report.py +++ b/shapash/report/project_report.py @@ -12,9 +12,10 @@ import plotly from shapash import SmartExplainer +from shapash.plots.plot_metrics import generate_confusion_matrix_plot +from shapash.plots.plot_univariate import generate_fig_univariate from shapash.report.common import compute_col_types, display_value, get_callable, series_dtype from shapash.report.data_analysis import perform_global_dataframe_analysis, perform_univariate_dataframe_analysis -from shapash.report.plots import generate_confusion_matrix_plot, generate_fig_univariate from shapash.report.visualisation import ( convert_fig_to_html, print_css_style, @@ -52,7 +53,7 @@ class ProjectReport: Attributes ---------- explainer : shapash.explainer.smart_explainer.SmartExplainer - A shapash SmartExplainer object that has already be compiled. + A shapash SmartExplainer object that has already be compiled. metadata : dict Information about the project (author, description, ...). x_train : pd.DataFrame diff --git a/tests/unit_tests/report/test_plots.py b/tests/unit_tests/report/test_plots.py index 6dd764b2..75db770a 100644 --- a/tests/unit_tests/report/test_plots.py +++ b/tests/unit_tests/report/test_plots.py @@ -6,7 +6,7 @@ import pandas as pd from shapash.report.common import VarType -from shapash.report.plots import ( +from shapash.plots.plot_univariate import ( generate_fig_univariate, generate_fig_univariate_categorical, generate_fig_univariate_continuous, From 761139761ad24bafeb22ce0cb81c2065e70ff732 Mon Sep 17 00:00:00 2001 From: Guillaume VIGNAL Date: Mon, 9 Dec 2024 11:05:06 +0100 Subject: [PATCH 2/5] Transform additionnal plots --- pyproject.toml | 1 - shapash/explainer/smart_plotter.py | 120 ++- shapash/plots/plot_correlations.py | 21 +- ...ediction.py => plot_evaluation_metrics.py} | 157 ++- shapash/plots/plot_metrics.py | 50 - shapash/plots/plot_univariate.py | 510 +++++++--- shapash/report/project_report.py | 23 +- shapash/report/visualisation.py | 40 +- shapash/style/colors.json | 20 + shapash/style/style_utils.py | 27 + shapash/utils/utils.py | 23 +- tests/unit_tests/report/test_plots.py | 109 +- ...dditional_plots_visualizations.ipynb.ipynb | 938 ++++++++++++++++++ 13 files changed, 1768 insertions(+), 271 deletions(-) rename shapash/plots/{plot_scatter_prediction.py => plot_evaluation_metrics.py} (79%) delete mode 100644 shapash/plots/plot_metrics.py create mode 100644 tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb.ipynb diff --git a/pyproject.toml b/pyproject.toml index 499abd93..96c73d14 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -54,7 +54,6 @@ report = [ "nbconvert>=6.0.7", "papermill>=2.0.0", "jupyter-client>=7.4.0", - "seaborn==0.12.2", "notebook", "Jinja2>=2.11.0", "phik", diff --git a/shapash/explainer/smart_plotter.py b/shapash/explainer/smart_plotter.py index f135edb6..6b68f619 100644 --- a/shapash/explainer/smart_plotter.py +++ b/shapash/explainer/smart_plotter.py @@ -4,6 +4,7 @@ import math import random +from typing import Optional import numpy as np import pandas as pd @@ -16,11 +17,12 @@ 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_evaluation_metrics import plot_confusion_matrix, plot_scatter_prediction from shapash.plots.plot_feature_importance import plot_feature_importance from shapash.plots.plot_interactions import plot_interactions_scatter, plot_interactions_violin, update_interactions_fig from shapash.plots.plot_line_comparison import plot_line_comparison -from shapash.plots.plot_scatter_prediction import plot_scatter_prediction from shapash.plots.plot_stability import plot_amplitude_vs_stability, plot_stability_distribution +from shapash.plots.plot_univariate import plot_distribution from shapash.style.style_utils import colors_loading, define_style, select_palette from shapash.utils.sampling import subset_sampling from shapash.utils.utils import ( @@ -1852,3 +1854,119 @@ def scatter_plot_prediction( ) return fig + + def confusion_matrix_plot( + self, + width: int = 700, + height: int = 500, + file_name=None, + auto_open=False, + ): + """ + Returns a matplotlib figure containing a confusion matrix that is computed using y_true and + y_pred parameters. + + Parameters + ---------- + y_true : array-like + Ground truth (correct) target values. + y_pred : array-like + Estimated targets as returned by a classifier. + colors_dict : dict + dict of colors used + width : int, optional, default=7 + The width of the generated figure, in inches. + height : int, optional, default=4 + The height of the generated figure, in inches. + + Returns + ------- + matplotlib.pyplot.Figure + """ + + # Classification Case + if self._explainer._case == "classification": + y_true = self._explainer.y_target.iloc[:, 0] + y_pred = self._explainer.y_pred.iloc[:, 0] + if self._explainer.label_dict is not None: + y_true = y_true.map(self._explainer.label_dict) + y_pred = y_pred.map(self._explainer.label_dict) + # Regression Case + elif self._explainer._case == "regression": + raise (ValueError("Confusion matrix is only available for classification case")) + + return plot_confusion_matrix( + y_true=y_true, + y_pred=y_pred, + colors_dict=self._style_dict, + width=width, + height=height, + file_name=file_name, + auto_open=auto_open, + ) + + def distribution_plot( + self, + col: str, + hue: Optional[str] = None, + width: int = 700, + height: int = 500, + nb_cat_max: int = 7, + nb_hue_max: int = 7, + file_name=None, + auto_open=False, + ) -> go.Figure: + """ + Generate a Plotly figure displaying the univariate distribution of a feature + (continuous or categorical) in the dataset. + + For categorical features with too many unique categories, the least frequent + categories are grouped into a new 'Other' category to ensure the plot remains + readable. Continuous features are visualized using KDE plots. + + The input DataFrame must contain the column of interest (`col`) and a second column + (`hue`) used to distinguish between two groups (e.g., 'train' and 'test'). + + Parameters + ---------- + col : str + The name of the column of interest whose distribution is to be visualized. + hue : Optional[str], optional + The name of the column used to differentiate between groups. + width : int, optional, default=700 + The width of the generated figure, in pixels. + height : int, optional, default=500 + The height of the generated figure, in pixels. + nb_cat_max : int, optional, default=7 + Maximum number of categories to display. Categories beyond this limit + are grouped into a new 'Other' category (only for categorical features). + 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. + file_name : str, optional + Path to save the plot as an HTML file. If None, the plot will not be saved, by default None. + auto_open : bool, optional + If True, the plot will automatically open in a web browser after being generated, by default False. + + Returns + ------- + go.Figure + A Plotly figure object representing the distribution of the feature. + """ + if self._explainer.y_target is not None: + data = pd.concat([self._explainer.x_init, self._explainer.y_target], axis=1) + else: + data = self._explainer.x_init + + return plot_distribution( + data, + col, + hue=hue, + colors_dict=self._style_dict, + width=width, + height=height, + nb_cat_max=nb_cat_max, + nb_hue_max=nb_hue_max, + file_name=file_name, + auto_open=auto_open, + ) diff --git a/shapash/plots/plot_correlations.py b/shapash/plots/plot_correlations.py index fd6b4958..e5b22393 100644 --- a/shapash/plots/plot_correlations.py +++ b/shapash/plots/plot_correlations.py @@ -1,3 +1,5 @@ +from typing import Optional + import numpy as np import pandas as pd import scipy.cluster.hierarchy as sch @@ -6,12 +8,14 @@ from plotly.subplots import make_subplots from shapash.manipulation.summarize import compute_corr +from shapash.style.style_utils import define_style, get_palette from shapash.utils.utils import adjust_title_height, compute_top_correlations_features, suffix_duplicates def plot_correlations( df, - style_dict, + style_dict: Optional[dict] = None, + palette_name: str = "default", features_dict=None, optimized=False, max_features=20, @@ -35,6 +39,8 @@ def plot_correlations( DataFrame for which we want to compute correlations. 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 @@ -123,6 +129,15 @@ def prepare_corr_matrix(df_subset): list_features_shorten = suffix_duplicates(list_features_shorten) return corr, list_features, list_features_shorten + 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)) + if features_dict is None: features_dict = {} @@ -203,10 +218,10 @@ def prepare_corr_matrix(df_subset): if len(list_features) < len(df.drop(features_to_hide, axis=1).columns): subtitle = f"Top {len(list_features)} correlations" title += f"
{subtitle}" - dict_t = style_dict["dict_title"] | {"text": title, "y": adjust_title_height(height)} + dict_t = style_dict_default["dict_title"] | {"text": title, "y": adjust_title_height(height)} fig.update_layout( - coloraxis=dict(colorscale=["rgb(255, 255, 255)"] + style_dict["init_contrib_colorscale"][5:-1]), + coloraxis=dict(colorscale=["rgb(255, 255, 255)"] + style_dict_default["init_contrib_colorscale"][5:-1]), showlegend=True, title=dict_t, width=width, diff --git a/shapash/plots/plot_scatter_prediction.py b/shapash/plots/plot_evaluation_metrics.py similarity index 79% rename from shapash/plots/plot_scatter_prediction.py rename to shapash/plots/plot_evaluation_metrics.py index 67479ba9..8ba812ab 100644 --- a/shapash/plots/plot_scatter_prediction.py +++ b/shapash/plots/plot_evaluation_metrics.py @@ -1,8 +1,11 @@ +from typing import Optional, Union + import numpy as np import pandas as pd from plotly import graph_objs as go from plotly.offline import plot +from shapash.style.style_utils import define_style, get_palette from shapash.utils.sampling import subset_sampling from shapash.utils.utils import adjust_title_height, truncate_str, tuning_colorscale @@ -356,7 +359,6 @@ def _prediction_regression_plot(y_target, y_pred, prediction_error, list_ind, st fig = go.Figure() subtitle = None - prediction_error = prediction_error if prediction_error is not None: if (y_target == 0).any().iloc[0]: subtitle = "Prediction Error = abs(True Values - Predicted Values)" @@ -458,8 +460,8 @@ def _prediction_regression_plot(y_target, y_pred, prediction_error, list_ind, st "y": 1.1, } range_axis = [ - min(min(y_target_values), min(y_pred_flatten)), - max(max(y_target_values), max(y_pred_flatten)), + min(y_target_values.min(), y_pred_flatten.min()), + max(y_target_values.max(), y_pred_flatten.max()), ] fig.update_xaxes(range=range_axis) fig.update_yaxes(range=range_axis) @@ -479,3 +481,152 @@ def _prediction_regression_plot(y_target, y_pred, prediction_error, list_ind, st ) return fig, subtitle + + +def plot_confusion_matrix( + y_true: Union[np.ndarray, list], + y_pred: Union[np.ndarray, list], + colors_dict: Optional[dict] = None, + width: int = 700, + height: int = 500, + palette_name: str = "default", + file_name=None, + auto_open=False, +) -> go.Figure: + """ + Creates an interactive confusion matrix using Plotly. + + Parameters + ---------- + y_true : array-like + Ground truth (correct) target values. + y_pred : array-like + Estimated targets as returned by a classifier. + colors_dict : dict, optional + Custom colors for the confusion matrix. + width : int, optional + The width of the figure in pixels. + height : int, optional + The height of the figure in pixels. + palette_name : str, optional + The color palette to use for the heatmap. + file_name: string, optional + Specify the save path of html files. If None, no file will be saved. + auto_open: bool, optional + Automatically open the plot. + + Returns + ------- + go.Figure + The generated confusion matrix as a Plotly figure. + """ + # Create a confusion matrix as a DataFrame + labels = sorted(set(y_true).union(set(y_pred))) + se_y_true = pd.Series(y_true, name="Actual") + se_y_pred = pd.Series(y_pred, name="Predicted") + df_cm = pd.crosstab(se_y_true, se_y_pred).reindex(index=labels, columns=labels, fill_value=0) + + if colors_dict: + style_dict = {} + keys = ["dict_title", "init_confusion_matrix_colorscale", "dict_xaxis", "dict_yaxis"] + if any(key not in colors_dict for key in keys): + style_dict = define_style(get_palette(palette_name)) + style_dict.update(colors_dict) + else: + style_dict = define_style(get_palette(palette_name)) + + init_colorscale = style_dict["init_confusion_matrix_colorscale"] + linspace = np.linspace(0, 1, len(init_colorscale)) + col_scale = [(value, color) for value, color in zip(linspace, init_colorscale)] + + # Convert the DataFrame to a NumPy array + x_labels = list(df_cm.columns) + y_labels = list(df_cm.index) + z = df_cm.loc[x_labels, y_labels].values + + title = "Confusion Matrix" + dict_t = style_dict["dict_title"] | {"text": title, "y": adjust_title_height(height)} + dict_xaxis = style_dict["dict_xaxis"] | {"text": se_y_pred.name} + dict_yaxis = style_dict["dict_yaxis"] | {"text": se_y_true.name} + + # Determine if labels are numeric + x_numeric = all(str(label).isdigit() for label in x_labels) + y_numeric = all(str(label).isdigit() for label in y_labels) + + hv_text = [ + [f"Actual: {y}
Predicted: {x}
Count: {value}" for x, value in zip(x_labels, row)] + for y, row in zip(y_labels, z) + ] + + if not x_numeric: + if len(x_labels) < 6: + k = 10 + else: + k = 6 + + # Shorten labels that exceed the threshold + x_labels = [x.replace(x[k + k // 2 : -k + k // 2], "...") if len(x) > 2 * k + 3 else x for x in x_labels] + + if not y_numeric: + if len(y_labels) < 6: + k = 10 + else: + k = 6 + + # Shorten labels that exceed the threshold + y_labels = [x.replace(x[k + k // 2 : -k + k // 2], "...") if len(x) > 2 * k + 3 else x for x in y_labels] + + # Create the heatmap using go.Heatmap + heatmap = go.Heatmap( + z=z, + x=x_labels, + y=y_labels, + colorscale=col_scale, + hovertext=hv_text, + hovertemplate="%{hovertext}", + showscale=True, + ) + + fig = go.Figure(data=[heatmap]) + + # Add annotations for each cell + annotations = [] + for i, y_label in enumerate(y_labels): + for j, x_label in enumerate(x_labels): + annotations.append( + dict( + x=x_label, + y=y_label, + text=str(z[i][j]), + showarrow=False, + font=dict(color="black" if z[i][j] < z.max() / 2 else "white"), + ) + ) + + # Update layout + fig.update_layout( + annotations=annotations, + title=dict_t, + xaxis=dict( + title=dict_xaxis, + tickangle=45, + tickmode="array" if x_numeric else "linear", + tickvals=[int(label) for label in x_labels] if x_numeric else None, + ticktext=x_labels if x_numeric else None, + ), + yaxis=dict( + title=dict_yaxis, + autorange="reversed", # Reverse y-axis to match conventional confusion matrix + tickmode="array" if y_numeric else "linear", + tickvals=[int(label) for label in y_labels] if y_numeric else None, + ticktext=y_labels if y_numeric else None, + ), + width=width, + height=height, + margin=dict(l=150, r=20, t=100, b=70), + ) + + if file_name: + plot(fig, filename=file_name, auto_open=auto_open) + + return fig diff --git a/shapash/plots/plot_metrics.py b/shapash/plots/plot_metrics.py deleted file mode 100644 index 58d6f472..00000000 --- a/shapash/plots/plot_metrics.py +++ /dev/null @@ -1,50 +0,0 @@ -from typing import Optional, Union - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -import seaborn as sns -from matplotlib.colors import LinearSegmentedColormap - -from shapash.style.style_utils import get_palette, get_pyplot_color - - -def generate_confusion_matrix_plot( - y_true: Union[np.array, list], - y_pred: Union[np.array, list], - colors_dict: Optional[dict] = None, - width: int = 7, - height: int = 4, - palette_name: str = "default", -) -> plt.Figure: - """ - Returns a matplotlib figure containing a confusion matrix that is computed using y_true and - y_pred parameters. - - Parameters - ---------- - y_true : array-like - Ground truth (correct) target values. - y_pred : array-like - Estimated targets as returned by a classifier. - colors_dict : dict - dict of colors used - width : int, optional, default=7 - The width of the generated figure, in inches. - height : int, optional, default=4 - The height of the generated figure, in inches. - palette_name : str, optional, default="default" - The name of the color palette to be used if `colors_dict` is not provided. - - Returns - ------- - matplotlib.pyplot.Figure - """ - colors_dict = colors_dict or get_palette(palette_name) - col_scale = get_pyplot_color(colors=colors_dict["report_confusion_matrix"]) - cmap_gradient = LinearSegmentedColormap.from_list("col_corr", col_scale, N=100) - - df_cm = pd.crosstab(y_true, y_pred, rownames=["Actual"], colnames=["Predicted"]) - fig, ax = plt.subplots(figsize=(width, height)) - sns.heatmap(df_cm, ax=ax, annot=True, cmap=cmap_gradient, fmt="g") - return fig diff --git a/shapash/plots/plot_univariate.py b/shapash/plots/plot_univariate.py index 88c658d3..2c934e92 100644 --- a/shapash/plots/plot_univariate.py +++ b/shapash/plots/plot_univariate.py @@ -1,32 +1,37 @@ +import warnings from typing import Optional -import matplotlib.pyplot as plt import numpy as np import pandas as pd -import seaborn as sns +from plotly import graph_objs as go +from plotly.offline import plot +from scipy.stats import gaussian_kde -from shapash.report.common import VarType -from shapash.style.style_utils import get_palette, get_pyplot_color -from shapash.utils.utils import truncate_str +from shapash.report.common import VarType, series_dtype +from shapash.style.style_utils import define_style, get_palette, random_color +from shapash.utils.utils import adjust_title_height, compute_digit_number -def generate_fig_univariate( +def plot_distribution( df_all: pd.DataFrame, col: str, - hue: str, - serie_type: VarType, + hue: Optional[str] = None, colors_dict: Optional[dict] = None, - width: int = 7, - height: int = 4, + width: int = 700, + height: int = 500, palette_name: str = "default", -) -> plt.Figure: + nb_cat_max: int = 7, + nb_hue_max: int = 7, + file_name=None, + auto_open=False, +) -> go.Figure: """ - Generate a matplotlib figure displaying the univariate distribution of a feature + Generate a Plotly figure displaying the univariate distribution of a feature (continuous or categorical) in the dataset. For categorical features with too many unique categories, the least frequent categories are grouped into a new 'Other' category to ensure the plot remains - readable. Continuous features are visualized using histograms. + readable. Continuous features are visualized using KDE plots. The input DataFrame must contain the column of interest (`col`) and a second column (`hue`) used to distinguish between two groups (e.g., 'train' and 'test'). @@ -37,49 +42,90 @@ def generate_fig_univariate( The input DataFrame containing the data to be plotted. col : str The name of the column of interest whose distribution is to be visualized. - hue : str + hue : Optional[str], optional The name of the column used to differentiate between groups (e.g., 'train' and 'test'). - serie_type : VarType - The type of the feature, either 'continuous' or 'categorical'. - colors_dict : dict, optional + colors_dict : Optional[dict], optional A dictionary specifying the colors to be used for each group. If not provided, a default color palette will be used. - width : int, optional, default=7 - The width of the generated figure, in inches. - height : int, optional, default=4 - The height of the generated figure, in inches. + width : int, optional, default=700 + The width of the generated figure, in pixels. + height : int, optional, default=500 + The height of the generated figure, in pixels. palette_name : str, optional, default="default" The name of the color palette to be used if `colors_dict` is not provided. + nb_cat_max : int, optional, default=7 + Maximum number of categories to display. Categories beyond this limit + are grouped into a new 'Other' category (only for categorical features). + 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. + file_name : str, optional + Path to save the plot as an HTML file. If None, the plot will not be saved, by default None. + auto_open : bool, optional + If True, the plot will automatically open in a web browser after being generated, by default False. Returns ------- - matplotlib.pyplot.Figure - A matplotlib figure object representing the distribution of the feature. + go.Figure + A Plotly figure object representing the distribution of the feature. """ + + serie_type = series_dtype(df_all[col]) + + if col not in df_all.columns: + raise ValueError(f"Column '{col}' not found in the input DataFrame.") + + if hue is not None and hue not in df_all.columns: + raise ValueError(f"Column '{hue}' not found in the input DataFrame.") + if serie_type == VarType.TYPE_NUM: - fig = generate_fig_univariate_continuous( - df_all, col, hue=hue, colors_dict=colors_dict, width=width, height=height, palette_name=palette_name + # Use the continuous plotting function + fig = plot_continuous_distribution( + df_all, + col, + hue=hue, + colors_dict=colors_dict, + width=width, + height=height, + palette_name=palette_name, + nb_hue_max=nb_hue_max, + file_name=file_name, + auto_open=auto_open, ) elif serie_type == VarType.TYPE_CAT: - fig = generate_fig_univariate_categorical( - df_all, col, hue=hue, colors_dict=colors_dict, width=width, height=height, palette_name=palette_name + # Use the categorical plotting function + fig = plot_categorical_distribution( + df_all, + col, + hue=hue, + colors_dict=colors_dict, + width=width, + height=height, + palette_name=palette_name, + nb_cat_max=nb_cat_max, + nb_hue_max=nb_hue_max, + file_name=file_name, + auto_open=auto_open, ) else: - raise NotImplementedError("Series dtype not supported") + raise NotImplementedError("The specified series type is not supported.") return fig -def generate_fig_univariate_continuous( +def plot_continuous_distribution( df_all: pd.DataFrame, col: str, - hue: str, + hue: Optional[str] = None, colors_dict: Optional[dict] = None, - width: int = 7, - height: int = 4, + width: int = 700, + height: int = 500, palette_name: str = "default", -) -> plt.Figure: + nb_hue_max: int = 7, + file_name=None, + auto_open=False, +) -> go.Figure: """ - Returns a matplotlib figure containing the distribution of a continuous feature. + Returns a Plotly figure containing the distribution of a continuous feature. Parameters ---------- @@ -87,147 +133,353 @@ def generate_fig_univariate_continuous( The input dataframe that contains the column of interest col : str The column of interest - hue : str - The column used to distinguish the values (ex. 'train' and 'test') - colors_dict : dict - dict of colors used - width : int, optional, default=7 - The width of the generated figure, in inches. - height : int, optional, default=4 - The height of the generated figure, in inches. + hue : Optional[str] + The column used to distinguish the values (e.g., 'train' and 'test'). + colors_dict : Optional[dict] + Dictionary of colors for hue levels. + width : int, optional, default=700 + The width of the generated figure, in pixels. + height : int, optional, default=500 + The height of the generated figure, in pixels. palette_name : str, optional, default="default" - The name of the color palette to be used if `colors_dict` is not provided. + The name of the color palette to use if `colors_dict` is not provided. + 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. + file_name : str, optional + Path to save the plot as an HTML file. If None, the plot will not be saved, by default None. + auto_open : bool, optional + If True, the plot will automatically open in a web browser after being generated, by default False. Returns ------- - matplotlib.pyplot.Figure + go.Figure + Plotly figure object representing the KDE plot. """ - colors_dict = colors_dict or get_palette(palette_name) - lower_quantile = df_all[:, col].quantile(0.005) - upper_quantile = df_all[:, col].quantile(0.995) - cond = (df_all[col] > lower_quantile) & (df_all[col] < upper_quantile) - - g = sns.displot( - df_all[cond], - x=col, - hue=hue, - kind="kde", - fill=True, - common_norm=False, - palette=get_pyplot_color(colors=colors_dict["report_feature_distribution"]), + if colors_dict: + style_dict = {} + keys = ["dict_title", "init_confusion_matrix_colorscale", "dict_xaxis", "dict_yaxis"] + if any(key not in colors_dict for key in keys): + style_dict = define_style(get_palette(palette_name)) + style_dict.update(colors_dict) + else: + style_dict = define_style(get_palette(palette_name)) + + lower_quantile = df_all[col].quantile(0.005) + upper_quantile = df_all[col].quantile(0.995) + filtered_data = df_all[(df_all[col] > lower_quantile) & (df_all[col] < upper_quantile)].copy() + + # Initialize the figure + fig = go.Figure() + + # Define colors for hue levels if provided + if hue: + unique_hues = filtered_data[hue].unique() + + if len(unique_hues) > nb_hue_max: + top_categories = filtered_data[hue].value_counts().nlargest(nb_hue_max).index + filtered_data[hue] = filtered_data[hue].where(filtered_data[hue].isin(top_categories), other="Other") + unique_hues = filtered_data[hue].unique() + + for level in unique_hues: + subset = filtered_data[filtered_data[hue] == level] + if len(subset) < 5: + warnings.warn( # noqa: B028 + f"Not enough data points to plot the curve for level '{level}' in the hue column '{hue}'. " + "At least 5 data points are required." + ) + continue + kde = gaussian_kde(subset[col]) + x_values = np.linspace(subset[col].min(), subset[col].max(), 500) + y_values = kde(x_values) + + # Generate hovertext + hv_text = [ + f"{hue}: {level}
" + f"{col}: {format(x, f'.{max(0, compute_digit_number(x, 3))}f')}
" + f"Density: {y:.4f}" + for x, y in zip(x_values, y_values) + ] + + color = style_dict.get(level, random_color()) + + fig.add_trace( + go.Scatter( + x=x_values, + y=y_values, + mode="lines", + line=dict(color=color), + name=str(level), + fill="tozeroy", + hoverinfo="text", + text=hv_text, + ) + ) + else: + if len(filtered_data[col]) < 5: + warnings.warn( # noqa: B028 + f"Not enough data points to plot the curve in the hue column '{hue}'. " + "At least 5 data points are required." + ) + return + kde = gaussian_kde(filtered_data[col]) + x_values = np.linspace(filtered_data[col].min(), filtered_data[col].max(), 500) + y_values = kde(x_values) + + # Generate hovertext + hv_text = [ + f"{col}: {format(x, f'.{max(0, compute_digit_number(x, 3))}f')}
" f"Density: {y:.4f}" + for x, y in zip(x_values, y_values) + ] + + color = style_dict.get(col, random_color()) + + fig.add_trace( + go.Scatter( + x=x_values, + y=y_values, + mode="lines", + line=dict(color=color), + name=col, + fill="tozeroy", + hoverinfo="text", + text=hv_text, + ) + ) + + title = f"Distribution of {col}" + dict_t = style_dict["dict_title"] | dict(text=title, y=adjust_title_height(height)) + dict_xaxis = style_dict["dict_xaxis"] | dict(text=col) + dict_yaxis = style_dict["dict_yaxis"] | dict(text="Density") + + # Update layout + fig.update_layout( + title=dict_t, + xaxis=dict(title=dict_xaxis, tickangle=30), + yaxis=dict(title=dict_yaxis), + width=width, + height=height, + margin=dict(l=90, r=20, t=100, b=70), + template="plotly_white", ) - g.set_xticklabels(rotation=30) - fig = g.figure + if hue: + fig.update_layout( + legend_title=dict( + text=hue, + font=dict(size=12), + ) + ) - fig.set_figwidth(width) - fig.set_figheight(height) + if file_name: + plot(fig, filename=file_name, auto_open=auto_open) return fig -def generate_fig_univariate_categorical( +def plot_categorical_distribution( df_all: pd.DataFrame, col: str, - hue: str, + hue: Optional[str] = None, nb_cat_max: int = 7, + nb_hue_max: int = 7, colors_dict: Optional[dict] = None, - width: int = 7, - height: int = 4, + width: int = 700, + height: int = 500, palette_name: str = "default", -) -> plt.Figure: + file_name=None, + auto_open=False, +) -> go.Figure: """ - Returns a matplotlib figure containing the distribution of a categorical feature. + Returns a Plotly Figure containing the distribution of a categorical feature. - If the feature is categorical and contains too many categories, the smallest - categories are grouped into a new 'Other' category so that the graph remains - readable. + If the feature contains too many categories, the smallest categories are grouped + into a new 'Other' category so that the graph remains readable. Parameters ---------- df_all : pd.DataFrame - The input dataframe that contains the column of interest + The input dataframe that contains the column of interest. col : str - The column of interest - hue : str - The column used to distinguish the values (ex. 'train' and 'test') - nb_cat_max : int - The number max of categories to be displayed. If the number of categories - is greater than nb_cat_max then groups smallest categories into a new - 'Other' category - colors_dict : dict - dict of colors used - width : int, optional, default=7 - The width of the generated figure, in inches. - height : int, optional, default=4 - The height of the generated figure, in inches. + The column of interest. + hue : Optional[str] + The column used to distinguish the values (e.g., 'train' and 'test'). + nb_cat_max : int, optional, default=7 + Maximum number of categories to display. Categories beyond this limit + are grouped into a new 'Other' category. + 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. + colors_dict : Optional[dict] + Dictionary of colors for categories. + width : int, optional, default=700 + The width of the generated figure, in pixels. + height : int, optional, default=500 + The height of the generated figure, in pixels. palette_name : str, optional, default="default" - The name of the color palette to be used if `colors_dict` is not provided. + The name of the color palette to use if `colors_dict` is not provided. + file_name : str, optional + Path to save the plot as an HTML file. If None, the plot will not be saved, by default None. + auto_open : bool, optional + If True, the plot will automatically open in a web browser after being generated, by default False. Returns ------- - matplotlib.pyplot.Figure + go.Figure + Plotly figure object representing the bar plot. """ - colors_dict = colors_dict or get_palette(palette_name) - df_cat = df_all.groupby([col, hue]).agg({col: "count"}).rename(columns={col: "count"}).reset_index() - df_cat["Percent"] = df_cat["count"] * 100 / df_cat.groupby(hue)["count"].transform("sum") + df_all = df_all.copy() + if colors_dict: + style_dict = {} + keys = ["dict_title", "init_confusion_matrix_colorscale", "dict_xaxis", "dict_yaxis"] + if any(key not in colors_dict for key in keys): + style_dict = define_style(get_palette(palette_name)) + style_dict.update(colors_dict) + else: + style_dict = define_style(get_palette(palette_name)) + + if hue: + unique_hues = df_all[hue].unique() + if len(unique_hues) > nb_hue_max: + top_categories = df_all[hue].value_counts().nlargest(nb_hue_max).index + df_all[hue] = df_all[hue].where(df_all[hue].isin(top_categories), other="Other") + + df_cat = df_all.groupby([col, hue])[col].count().rename("count").reset_index() + df_cat["Percent"] = df_cat["count"] * 100 / df_cat.groupby(hue)["count"].transform("sum") + else: + df_cat = df_all[col].value_counts().reset_index(name="count") + df_cat["Percent"] = df_cat["count"] * 100 / df_cat["count"].sum() if pd.api.types.is_numeric_dtype(df_cat[col].dtype): df_cat = df_cat.sort_values(col, ascending=True) df_cat[col] = df_cat[col].astype(str) - nb_cat = df_cat.groupby([col]).agg({"count": "sum"}).reset_index()[col].nunique() + nb_cat = df_cat[col].nunique() if nb_cat > nb_cat_max: df_cat = _merge_small_categories(df_cat=df_cat, col=col, hue=hue, nb_cat_max=nb_cat_max) - fig, ax = plt.subplots(figsize=(width, height)) + total_counts = df_cat.groupby(col)["count"].sum() + category_order = total_counts.sort_values().index + if hue: + hue_order = np.sort(df_cat[hue].unique()) + full_combinations = pd.MultiIndex.from_product([category_order, hue_order], names=[col, hue]) + df_cat = df_cat.set_index([col, hue]).reindex(full_combinations, fill_value=0).reset_index() + else: + df_cat = df_cat.set_index(col).reindex(category_order, fill_value=0).reset_index() + + df_cat[col] = pd.Categorical(df_cat[col], categories=category_order, ordered=True) + + data = [] + if hue: + for hue_val in hue_order: + subset = df_cat[df_cat[hue] == hue_val] + color = style_dict.get(hue_val, random_color()) + + customdata = subset.apply( + lambda row, hue_val=hue_val: ( + f"{hue}: {hue_val}
" + f"{col}: {row[col]}
" + f"Percentage: {format(row.Percent, f'.{max(0, compute_digit_number(row.Percent, 3))}f')}%" + ), + axis=1, + ) + + bar = go.Bar( + x=subset["Percent"], + y=subset[col], + orientation="h", + name=str(hue_val), + marker=dict(color=color), + customdata=customdata, + hovertemplate="%{customdata}", + ) + data.append(bar) + else: + color = style_dict.get(col, random_color()) + + customdata = subset.apply( + lambda row: ( + f"{col}: {row[col]}
" + f"Percentage: {format(row.Percent, f'.{max(0, compute_digit_number(row.Percent, 3))}f')}%" + ), + axis=1, + ) - sns.barplot( - data=df_cat, - x="Percent", - y=col, - hue=hue, - palette=get_pyplot_color(colors=colors_dict["report_feature_distribution"]), - ax=ax, + bar = go.Bar( + x=df_cat["Percent"], + y=df_cat[col], + orientation="h", + name=col, + marker=dict(color=color), + customdata=customdata, + hovertemplate="%{customdata}", + ) + data = [bar] + + fig = go.Figure(data=data) + + title = f"Distribution of {col}" + dict_t = style_dict["dict_title"] | dict(text=title, y=adjust_title_height(height)) + dict_xaxis = style_dict["dict_xaxis"] | dict(text="Percentage") + dict_yaxis = style_dict["dict_yaxis"] | dict(text=col) + + fig.update_layout( + title=dict_t, + xaxis_title=dict_xaxis, + yaxis_title=dict_yaxis, + barmode="group", + width=width, + height=height, + margin=dict(l=110, r=20, t=100, b=70), + template="plotly_white", ) - for p in ax.patches: - ax.annotate( - f"{np.nan_to_num(p.get_width(), nan=0):.1f}%", - xy=(p.get_width(), p.get_y() + p.get_height() / 2), - xytext=(5, 0), - textcoords="offset points", - ha="left", - va="center", + # Add legend title only if hue is specified + if hue: + fig.update_layout( + legend_title=dict( + text=hue, + font=dict(size=12), + ) ) - # Shrink current axis by 20% - box = ax.get_position() - ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) - - # Put a legend to the right of the current axis - ax.legend(loc="center left", bbox_to_anchor=(1, 0.5)) - - # Removes plot borders - ax.spines["top"].set_visible(False) - ax.spines["right"].set_visible(False) - - new_labels = [truncate_str(i.get_text(), maxlen=45) for i in ax.yaxis.get_ticklabels()] - ax.yaxis.set_ticklabels(new_labels) + if file_name: + plot(fig, filename=file_name, auto_open=auto_open) return fig -def _merge_small_categories(df_cat: pd.DataFrame, col: str, hue: str, nb_cat_max: int) -> pd.DataFrame: +def _merge_small_categories(df_cat: pd.DataFrame, col: str, hue: Optional[str], nb_cat_max: int) -> pd.DataFrame: """ - Merges categories of column 'col' of df_cat into 'Other' category so that - the number of categories is less than nb_cat_max. + Merges smaller categories into a single "Other" category. + + Parameters + ---------- + df_cat : pd.DataFrame + Dataframe with category counts and percentages. + col : str + The column of interest. + hue : Optional[str] + Hue column to group by. + nb_cat_max : int + Maximum number of categories to retain. + + Returns + ------- + pd.DataFrame + Dataframe with smaller categories grouped into "Other". """ - df_cat_sum_hue = df_cat.groupby([col]).agg({"count": "sum"}).reset_index() - list_cat_to_merge = df_cat_sum_hue.sort_values("count", ascending=False)[col].to_list()[nb_cat_max - 1 :] - df_cat_other = ( - df_cat.loc[df_cat[col].isin(list_cat_to_merge)].groupby(hue, as_index=False)[["count", "Percent"]].sum() - ) - df_cat_other[col] = "Other" - return pd.concat([df_cat.loc[~df_cat[col].isin(list_cat_to_merge)], df_cat_other], axis=0) + total_counts = df_cat.groupby(col)["count"].sum() + sorted_categories = total_counts.sort_values(ascending=False).index + top_categories = sorted_categories[:nb_cat_max] + + df_cat[col] = np.where(df_cat[col].isin(top_categories), df_cat[col], "Other") + if hue: + df_cat = df_cat.groupby([col, hue]).agg({"count": "sum"}).reset_index() + df_cat["Percent"] = df_cat["count"] * 100 / df_cat.groupby(hue)["count"].transform("sum") + else: + df_cat = df_cat.groupby(col, as_index=False)["count"].sum() + df_cat["Percent"] = df_cat["count"] * 100 / df_cat["count"].sum() + + return df_cat diff --git a/shapash/report/project_report.py b/shapash/report/project_report.py index 3b705f40..c2d8dddf 100644 --- a/shapash/report/project_report.py +++ b/shapash/report/project_report.py @@ -12,12 +12,11 @@ import plotly from shapash import SmartExplainer -from shapash.plots.plot_metrics import generate_confusion_matrix_plot -from shapash.plots.plot_univariate import generate_fig_univariate +from shapash.plots.plot_evaluation_metrics import plot_confusion_matrix +from shapash.plots.plot_univariate import plot_distribution from shapash.report.common import compute_col_types, display_value, get_callable, series_dtype from shapash.report.data_analysis import perform_global_dataframe_analysis, perform_univariate_dataframe_analysis from shapash.report.visualisation import ( - convert_fig_to_html, print_css_style, print_html, print_javascript_misc, @@ -357,8 +356,11 @@ def _perform_and_display_analysis_univariate( ] for col_label in sorted(list_cols_labels): col = self.explainer.inv_features_dict.get(col_label, col_label) - fig = generate_fig_univariate( - df_all=df, col=col, hue=col_splitter, type=col_types[col], colors_dict=self.explainer.colors_dict + fig = plot_distribution( + df_all=df, + col=col, + hue=col_splitter, + colors_dict=self.explainer.colors_dict["report_feature_distribution"], ) df_col_stats = self._stats_to_table( test_stats=test_stats_univariate[col], @@ -373,7 +375,7 @@ def _perform_and_display_analysis_univariate( "type": str(series_dtype(df[col])), "description": col_label, "table": df_col_stats.to_html(classes="greyGridTable"), - "image": convert_fig_to_html(fig), + "image": plotly.io.to_html(fig, include_plotlyjs=False, full_html=False), } ) print_html(univariate_template.render(features=univariate_features_desc, groupId=group_id)) @@ -527,13 +529,10 @@ def display_model_performance(self): or metric["name"] == "confusion_matrix" ): print_md(f"**{metric['name']} :**") - print_html( - convert_fig_to_html( - generate_confusion_matrix_plot( - y_true=self.y_test, y_pred=self.y_pred, colors_dict=self.explainer.colors_dict - ) - ) + fig = plot_confusion_matrix( + y_true=self.y_test, y_pred=self.y_pred, colors_dict=self.explainer.colors_dict ) + print_html(plotly.io.to_html(fig, include_plotlyjs=False, full_html=False)) else: try: metric_fn = get_callable(path=metric["path"]) diff --git a/shapash/report/visualisation.py b/shapash/report/visualisation.py index 062ae458..d91601ec 100644 --- a/shapash/report/visualisation.py +++ b/shapash/report/visualisation.py @@ -36,13 +36,13 @@ def print_css_style(): margin-left: 5px; } table.greyGridTable tbody td { - border: solid 1px #DEDDEE; - color: #333; - padding: 5px; - margin-left: 10px; - margin-right: 10px; - text-align: center; - text-shadow: 1px 1px 1px #fff; + border: solid 1px #DEDDEE; + color: #333; + padding: 5px; + margin-left: 10px; + margin-right: 10px; + text-align: center; + text-shadow: 1px 1px 1px #fff; } table.greyGridTable thead th { border: solid 1px #DEDDEE; @@ -82,7 +82,7 @@ def print_css_style(): } .scrollable-menu > li{ - list-style:none; + list-style:none; } """ @@ -95,24 +95,24 @@ def print_javascript_misc(): """ """ @@ -135,8 +135,8 @@ def html_str_df_and_image(df: pd.DataFrame, fig: plt.Figure) -> str: """Convert dataframe to HTML display""" return f"""
-
{df.to_html(classes="greyGridTable")}
-
{convert_fig_to_html(fig)}
+
{df.to_html(classes="greyGridTable")}
+
{convert_fig_to_html(fig)}
""" diff --git a/shapash/style/colors.json b/shapash/style/colors.json index 2a4595ba..c21f9668 100644 --- a/shapash/style/colors.json +++ b/shapash/style/colors.json @@ -14,6 +14,14 @@ "rgba(129, 64, 0, 0.9)", "rgba(0, 98, 128, 0.9)" ], + "confusion_matrix_colorscale": [ + "rgb(230, 255, 255)", + "rgb(200, 230, 240)", + "rgb(100, 200, 220)", + "rgb(0, 154, 203)", + "rgb(0, 98, 128)", + "rgb(0, 70, 92)" + ], "contrib_colorscale": [ "rgb(168, 84, 0)", "rgb(204, 102, 0)", @@ -124,6 +132,18 @@ "rgba(0, 21, 179, 0.97)", "rgba(116, 1, 179, 0.9)" ], + "confusion_matrix_colorscale": [ + "rgb(255, 255, 220)", + "rgb(255, 249, 190)", + "rgb(255, 234, 120)", + "rgb(255, 216, 100)", + "rgb(255, 204, 83)", + "rgb(255, 192, 0)", + "rgb(255, 166, 17)", + "rgb(255, 123, 38)", + "rgb(255, 100, 23)", + "rgb(255, 77, 7)" + ], "contrib_colorscale": [ "rgb(52, 55, 54)", "rgb(74, 99, 138)", diff --git a/shapash/style/style_utils.py b/shapash/style/style_utils.py index f50e7f82..064aec83 100644 --- a/shapash/style/style_utils.py +++ b/shapash/style/style_utils.py @@ -5,9 +5,33 @@ import json import os +import numpy as np + from shapash.utils.utils import convert_string_to_int_keys +def random_color(a: float = 0.6) -> str: + """ + Generates a random RGBA color string. + + Parameters + ---------- + a : float, optional, default=0.6 + Alpha (transparency) value for the color. Must be between 0 and 1. + + Returns + ------- + str + A string representing a random RGBA color in the format "rgba(r, g, b, a)". + """ + if not (0 <= a <= 1): + raise ValueError("Alpha value 'a' must be between 0 and 1.") + + rng = np.random.default_rng() + r, g, b = rng.integers(0, 256, size=3) # Generate random RGB values + return f"rgba({r}, {g}, {b}, {a})" + + def colors_loading(): """ colors_loading allows shapash to load a json file which contains different @@ -106,6 +130,9 @@ def define_style(palette): style_dict["featureimp_groups"] = convert_string_to_int_keys(palette["featureimp_groups"]) style_dict["feature_contributions_cumulative"] = palette["feature_contributions_cumulative"] style_dict["init_contrib_colorscale"] = palette["contrib_colorscale"] + style_dict["init_confusion_matrix_colorscale"] = palette["confusion_matrix_colorscale"] + style_dict["report_confusion_matrix"] = palette["report_confusion_matrix"] + style_dict["report_feature_distribution"] = palette["report_feature_distribution"] style_dict["contrib_distribution"] = palette["contrib_distribution"] style_dict["violin_area_classif"] = convert_string_to_int_keys(palette["violin_area_classif"]) style_dict["prediction_plot"] = convert_string_to_int_keys(palette["prediction_plot"]) diff --git a/shapash/utils/utils.py b/shapash/utils/utils.py index 2f2ca5b4..47865401 100644 --- a/shapash/utils/utils.py +++ b/shapash/utils/utils.py @@ -198,7 +198,7 @@ def truncate_str(text, maxlen=40): return text -def compute_digit_number(value): +def compute_digit_number(value, significant_digits: int = 4): """ return int, number of digits to display @@ -206,6 +206,8 @@ def compute_digit_number(value): ---------- value : float can be the gap between percentiles + significant_digits : int, optional, default=4 + Fixed number of significant digits to display. Returns ------- @@ -221,8 +223,8 @@ def compute_digit_number(value): if scalar_value == 0: first_nz = 1 else: - first_nz = int(math.log10(abs(scalar_value))) - digit = abs(min(3, first_nz) - 3) + first_nz = math.ceil(math.log10(abs(scalar_value))) + digit = abs(min(significant_digits, first_nz) - significant_digits) return digit @@ -422,14 +424,13 @@ def tuning_colorscale(init_colorscale, values, keep_90_pct=False): data = data_tmp cmin, cmax = data.min(), data.max() - # Describe the data to get basic statistics - desc_df = data.describe(percentiles=np.arange(0.1, 1, 0.1).tolist()) + # Calculate only the quantiles corresponding to the color scale + quantiles = data.quantile(np.linspace(0, 1, len(init_colorscale))) - # Extract the initial min and max values - min_pred, max_init = desc_df.loc[["min", "max"]] - - # Adjust percentile values for color scale creation - desc_pct_df = (desc_df.loc[~desc_df.index.isin(["count", "mean", "std"])] - min_pred) / (max_init - min_pred) - color_scale = [(value, color) for value, color in zip(desc_pct_df.values.flatten(), init_colorscale)] + # Normalize quantiles to a 0-1 scale + min_pred, max_pred = quantiles.min(), quantiles.max() + normalized_quantiles = (quantiles - min_pred) / (max_pred - min_pred) + # Build the color scale + color_scale = [(value, color) for value, color in zip(normalized_quantiles, init_colorscale)] return color_scale, cmin, cmax diff --git a/tests/unit_tests/report/test_plots.py b/tests/unit_tests/report/test_plots.py index 75db770a..a6e78838 100644 --- a/tests/unit_tests/report/test_plots.py +++ b/tests/unit_tests/report/test_plots.py @@ -1,22 +1,22 @@ import unittest from unittest.mock import patch -import matplotlib.pyplot as plt import numpy as np import pandas as pd from shapash.report.common import VarType from shapash.plots.plot_univariate import ( - generate_fig_univariate, - generate_fig_univariate_categorical, - generate_fig_univariate_continuous, + plot_distribution, + plot_categorical_distribution, + plot_continuous_distribution, ) +from plotly import graph_objects as go class TestPlots(unittest.TestCase): - @patch("shapash.report.plots.generate_fig_univariate_continuous") - @patch("shapash.report.plots.generate_fig_univariate_categorical") - def test_generate_fig_univariate_1(self, mock_plot_cat, mock_plot_cont): + @patch("shapash.plots.plot_univariate.plot_continuous_distribution") + @patch("shapash.plots.plot_univariate.plot_categorical_distribution") + def test_plot_distribution_1(self, mock_plot_cat, mock_plot_cont): df = pd.DataFrame( { "string_data": ["a", "b", "c", "d", "e", np.nan], @@ -24,24 +24,24 @@ def test_generate_fig_univariate_1(self, mock_plot_cat, mock_plot_cont): } ) - generate_fig_univariate(df, "string_data", "data_train_test", type=VarType.TYPE_CAT) + plot_distribution(df, "string_data", "data_train_test") mock_plot_cat.assert_called_once() self.assertEqual(mock_plot_cont.call_count, 0) - @patch("shapash.report.plots.generate_fig_univariate_continuous") - @patch("shapash.report.plots.generate_fig_univariate_categorical") - def test_generate_fig_univariate_2(self, mock_plot_cat, mock_plot_cont): + @patch("shapash.plots.plot_univariate.plot_continuous_distribution") + @patch("shapash.plots.plot_univariate.plot_categorical_distribution") + def test_plot_distribution_2(self, mock_plot_cat, mock_plot_cont): df = pd.DataFrame( {"int_data": list(range(50)), "data_train_test": ["train", "train", "train", "train", "test"] * 10} ) - generate_fig_univariate(df, "int_data", "data_train_test", type=VarType.TYPE_NUM) + plot_distribution(df, "int_data", "data_train_test") mock_plot_cont.assert_called_once() self.assertEqual(mock_plot_cat.call_count, 0) - @patch("shapash.report.plots.generate_fig_univariate_continuous") - @patch("shapash.report.plots.generate_fig_univariate_categorical") - def test_generate_fig_univariate_3(self, mock_plot_cat, mock_plot_cont): + @patch("shapash.plots.plot_univariate.plot_continuous_distribution") + @patch("shapash.plots.plot_univariate.plot_categorical_distribution") + def test_plot_distribution_3(self, mock_plot_cat, mock_plot_cont): df = pd.DataFrame( { "int_cat_data": [10, 10, 20, 20, 20, 10], @@ -49,39 +49,58 @@ def test_generate_fig_univariate_3(self, mock_plot_cat, mock_plot_cont): } ) - generate_fig_univariate(df, "int_cat_data", "data_train_test", type=VarType.TYPE_CAT) + plot_distribution(df, "int_cat_data", "data_train_test") mock_plot_cat.assert_called_once() self.assertEqual(mock_plot_cont.call_count, 0) - def test_generate_fig_univariate_continuous(self): + def test_plot_continuous_distribution_1(self): df = pd.DataFrame( { - "int_data": [10, 20, 30, 40, 50, 0], - "data_train_test": ["train", "train", "train", "train", "test", "test"], + "int_data": [10, 20, 30, 40], } ) - fig = generate_fig_univariate_continuous(df, "int_data", "data_train_test") - assert isinstance(fig, plt.Figure) + fig = plot_continuous_distribution(df, "int_data") + assert isinstance(fig, go.Figure) + assert len(fig.data) == 1 + assert fig.data[0].type == "scatter" - def test_generate_fig_univariate_categorical_1(self): + def test_plot_continuous_distribution_2(self): + df = pd.DataFrame( + { + "int_data": [10, 20, 30, 40, 50, 30, 20, 0], + "data_train_test": ["train", "train", "train", "train", "test", "test", "test", "test"], + } + ) + fig = plot_continuous_distribution(df, "int_data", "data_train_test") + assert isinstance(fig, go.Figure) + assert len(fig.data) == 2 + assert fig.data[0].type == "scatter" + assert fig.data[1].type == "scatter" + + def test_plot_categorical_distribution_1(self): df = pd.DataFrame( {"int_data": [0, 0, 0, 1, 1, 0], "data_train_test": ["train", "train", "train", "train", "test", "test"]} ) - fig = generate_fig_univariate_categorical(df, "int_data", "data_train_test") + fig = plot_categorical_distribution(df, "int_data", "data_train_test") - assert len(fig.axes[0].patches) == 4 # Number of bars + assert len(fig.data) == 2 + assert fig.data[0].type == "bar" + assert fig.data[1].type == "bar" + assert len(fig.data[0]['x']) == 2 - def test_generate_fig_univariate_categorical_2(self): + def test_plot_categorical_distribution_2(self): df = pd.DataFrame( {"int_data": [0, 0, 0, 1, 1, 0], "data_train_test": ["train", "train", "train", "train", "train", "train"]} ) - fig = generate_fig_univariate_categorical(df, "int_data", "data_train_test") + fig = plot_categorical_distribution(df, "int_data", "data_train_test") - assert len(fig.axes[0].patches) == 2 # Number of bars + assert len(fig.data) == 1 + assert fig.data[0].type == "bar" + assert len(fig.data[0]['x']) == 2 - def test_generate_fig_univariate_categorical_3(self): + def test_plot_categorical_distribution_3(self): """ Test merging small categories into 'other' category """ @@ -123,11 +142,13 @@ def test_generate_fig_univariate_categorical_3(self): } ) - fig = generate_fig_univariate_categorical(df, "int_data", "data_train_test", nb_cat_max=7) + fig = plot_categorical_distribution(df, "int_data", "data_train_test", nb_cat_max=7) - assert len(fig.axes[0].patches) == 7 # Number of bars + assert len(fig.data) == 1 + assert fig.data[0].type == "bar" + assert len(fig.data[0]['x']) == 8 - def test_generate_fig_univariate_categorical_4(self): + def test_plot_categorical_distribution_4(self): """ Test merging small categories into 'other' category """ @@ -169,22 +190,27 @@ def test_generate_fig_univariate_categorical_4(self): } ) - fig = generate_fig_univariate_categorical(df, "int_data", "data_train_test", nb_cat_max=7) + fig = plot_categorical_distribution(df, "int_data", "data_train_test", nb_cat_max=7) # Number of bars (multiplied by two as we have train + test for each cat) - assert len(fig.axes[0].patches) == 7 * 2 + assert len(fig.data) == 2 + assert fig.data[0].type == "bar" + assert fig.data[1].type == "bar" + assert len(fig.data[0]['x']) == 8 - def test_generate_fig_univariate_categorical_5(self): + def test_plot_categorical_distribution_5(self): """ Test merging small categories into 'other' category """ df = pd.DataFrame({"int_data": [k for k in range(10) for _ in range(k)], "data_train_test": ["train"] * 45}) - fig = generate_fig_univariate_categorical(df, "int_data", "data_train_test", nb_cat_max=7) + fig = plot_categorical_distribution(df, "int_data", "data_train_test", nb_cat_max=7) - assert len(fig.axes[0].patches) == 7 # Number of bars + assert len(fig.data) == 1 + assert fig.data[0].type == "bar" + assert len(fig.data[0]['x']) == 8 - def test_generate_fig_univariate_categorical_6(self): + def test_plot_categorical_distribution_6(self): """ Test merging small categories into 'other' category """ @@ -195,9 +221,10 @@ def test_generate_fig_univariate_categorical_6(self): } ) - fig = generate_fig_univariate_categorical(df, "int_data", "data_train_test", nb_cat_max=7) - - print(len(fig.axes[0].patches)) + fig = plot_categorical_distribution(df, "int_data", "data_train_test", nb_cat_max=7) # Number of bars (multiplied by two as we have train + test for each cat) - assert len(fig.axes[0].patches) == 7 * 2 + assert len(fig.data) == 2 + assert fig.data[0].type == "bar" + assert fig.data[1].type == "bar" + assert len(fig.data[0]['x']) == 8 diff --git a/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb.ipynb b/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb.ipynb new file mode 100644 index 00000000..bdfe811f --- /dev/null +++ b/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb.ipynb @@ -0,0 +1,938 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploring and Visualizing Data Distributions\n", + "\n", + "This tutorial demonstrates how to use Shapash to explore and visualize feature distributions in a dataset. By analyzing distributions, we gain a better understanding of the data, identify patterns, and spot potential issues such as outliers or imbalances.\n", + "\n", + "We will use the Kaggle [Titanic dataset](https://www.kaggle.com/c/titanic/data)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import ExtraTreesClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from shapash.data.data_loader import data_loading\n", + "from category_encoders import OrdinalEncoder\n", + "from shapash import SmartExplainer\n", + "from shapash.plots.plot_correlations import plot_correlations\n", + "from shapash.plots.plot_univariate import plot_distribution\n", + "from shapash.plots.plot_evaluation_metrics import plot_confusion_matrix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Titanic Dataset\n", + "We start by loading and preprocessing the Titanic dataset, which contains passenger information. The target variable is `Pclass`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SurvivedPclassSexAgeSibSpParchFareEmbarkedTitle
PassengerId
10Third classmale22.0107.25SouthamptonMr
21First classfemale38.01071.28CherbourgMrs
31Third classfemale26.0007.92SouthamptonMiss
41First classfemale35.01053.10SouthamptonMrs
50Third classmale35.0008.05SouthamptonMr
\n", + "
" + ], + "text/plain": [ + " Survived Pclass Sex Age SibSp Parch Fare \\\n", + "PassengerId \n", + "1 0 Third class male 22.0 1 0 7.25 \n", + "2 1 First class female 38.0 1 0 71.28 \n", + "3 1 Third class female 26.0 0 0 7.92 \n", + "4 1 First class female 35.0 1 0 53.10 \n", + "5 0 Third class male 35.0 0 0 8.05 \n", + "\n", + " Embarked Title \n", + "PassengerId \n", + "1 Southampton Mr \n", + "2 Cherbourg Mrs \n", + "3 Southampton Miss \n", + "4 Southampton Mrs \n", + "5 Southampton Mr " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load dataset\n", + "titanic_df, titanic_dict = data_loading('titanic')\n", + "\n", + "# Preprocessing\n", + "titanic_df.drop(columns=['Name'], inplace=True)\n", + "y_df = titanic_df[['Pclass']]\n", + "X_df = titanic_df.drop(columns=['Pclass'])\n", + "\n", + "# Show sample data\n", + "titanic_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualizing Correlations in the Dataset\n", + "\n", + "Understanding the relationships between features in a dataset is a crucial step in exploratory data analysis. Correlation matrices help identify how strongly pairs of variables are related. \n", + "\n", + "Using `plot_correlations`, we can generate a heatmap to visualize the correlation coefficients between all numerical features in the dataset. The heatmap uses a color gradient to represent the strength and direction of correlations:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_correlations(titanic_df, width=500, height=450, palette_name=\"blues\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explore Feature Distributions\n", + "Visualize the distributions of key features to better understand the dataset. We can do it before creating the model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_distribution(df_all=X_df, col='Embarked', hue='Title', height=500, nb_cat_max=7, nb_hue_max=5, width=800)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plot_distribution(df_all=X_df, col='Age', hue='Title', nb_hue_max=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Encode Categorical Features\n", + "Ordinal encoding is applied to transform categorical features into numeric format for model training." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Identify categorical features\n", + "categorical_features = [col for col in X_df.columns if X_df[col].dtype == 'object']\n", + "\n", + "# Apply encoding\n", + "encoder = OrdinalEncoder(cols=categorical_features, handle_unknown='ignore').fit(X_df)\n", + "encoder_target = OrdinalEncoder(cols=['Pclass'], handle_unknown='ignore').fit(y_df)\n", + "\n", + "X_df = encoder.transform(X_df)\n", + "y_df = encoder_target.transform(y_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Split Data and Train Model\n", + "We split the data into training and testing sets and train an ExtraTreesClassifier." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
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)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Split data\n", + "Xtrain, Xtest, ytrain, ytest = train_test_split(X_df, y_df, train_size=0.75, random_state=7)\n", + "\n", + "# Reset indices\n", + "Xtrain.reset_index(drop=True, inplace=True)\n", + "ytrain.reset_index(drop=True, inplace=True)\n", + "Xtest.reset_index(drop=True, inplace=True)\n", + "ytest.reset_index(drop=True, inplace=True)\n", + "\n", + "# Train model\n", + "clf = ExtraTreesClassifier(n_estimators=200, random_state=7)\n", + "clf.fit(Xtrain, ytrain.iloc[:, 0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compile Explainability Model\n", + "We use SmartExplainer to create an explainability framework for analyzing model predictions." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Shap explainer type - \n" + ] + } + ], + "source": [ + "# Mapping encoded labels to original labels\n", + "mappings = encoder_target.mapping[0]\n", + "encoded_to_original = {v: k for k, v in mappings['mapping'].items()}\n", + "encoded_to_original.pop(-2) # Remove invalid mappings\n", + "\n", + "# Initialize SmartExplainer\n", + "xpl = SmartExplainer(model=clf, preprocessing=encoder, features_dict=titanic_dict, label_dict=encoded_to_original)\n", + "\n", + "# Compile explainability model\n", + "xpl.compile(x=Xtest, y_target=ytest.iloc[:, 0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization\n", + "\n", + "We can conveniently display the previous plots for the test set and the confusion matrix using built-in functions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfQAAAHCCAYAAAAZ9Ts6AAAgAElEQVR4XuyddXwVRxeG3xASSEhwhxYpLsUpUqFAS3F3p0BxdwjB3d3drUAppTjFCqW4tbgVp1A8IeT7zfAlJBDI3ey5d8PNu/+0JGfOzj4zuc+O7F6XwMDAQPAgARIgARIgARL4oAm4UOgfdPux8iRAAiRAAiSgCVDo7AgkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDJEACJEACJOAEBCh0J2hEXgIJkAAJkAAJUOjsAyRAAiRAAiTgBAQodCdoRF4CCZAACZAACVDo7AMkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDJEACJEACJOAEBCh0J2hEXgIJkAAJkAAJUOjsAyRAAiRAAiTgBAQodCdoRF4CCZAACZAACVDo7AMkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDJEACJEACJOAEBCh0J2hEXgIJkAAJkAAJUOjsAyRAAiRAAiTgBAQodCdoRF4CCZAACZAACVDo7AMkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDJEACJEACJOAEBCh0J2hEXgIJkAAJkAAJUOjsAyRAAiRAAiTgBAQodCdoRF4CCZAACZAACVDo7AMkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDJEACJEACJOAEBCh0J2hEXgIJkAAJkAAJUOjsAyRAAiRAAiTgBAQodCdoRF4CCZAACZAACVDo7AMkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDJEACJEACJOAEBCh0J2hEXgIJkAAJkAAJUOjsAyRAAiRAAiTgBAQodCdoRF4CCZAACZAACVDo7AMkQAIkQAIk4AQEKHQnaEReAgmQAAmQAAlQ6OwDdiHw9OlTrF27Frt378bZs2fx77//Inr06EiSJAny5MmDChUqIHPmzHY5t9VJmzVrhj/++ANdunRB9erVHVodK88tcaEtW7bE77//jiVLliB9+vQSKVGjRg2cOXMGgwYNQokSJQzlfB/PiOQNDAxEzZo1cfnyZaxatQpJkyY1VB8Gk8D7CFDo7B/iBLZu3ao/PJXE33d8++236NatG+LEiSNeBysT2kuqjRo1wpEjR9CrVy9UrFgxzEu017kdwXPnzp1o164dVL8YPHiw2CkjIt6gk0sLXeX97bff0L59e31zof5OeJCAFAEKXYok82gCK1euDP6QUqPxOnXqoGDBgnok4uLiglu3buHPP//E6tWrcfz4cbRt2xb16tVzKnr2kqozCz0gIABVqlTRI1fVh1KnTi3WJyKb0NWF1a1bFydPnsTcuXORLVs2sWtloqhNgEKP2u0vevXqA6phw4Z48eIFPvvsM4wYMQKenp7vPMfmzZvx5MkTlCtXTrQeViezUuhWX3tEz79t2zZ06tQJuXPnxvTp0yOaJsxyZoT+voqYyaum2wcOHIhvvvkGQ4YMEb1eJou6BCj0qNv24lfevHlz7N+/H4kTJ8by5cvh5eUlfo4PISGFbryVgpj5+vqK3+CZEa+9hP7o0SMt85cvX+Lnn39GwoQJjUNjCRJ4gwCFzi4hQuDq1asoX768zqXWB9VUe0QPNf26bt06/UGnNjOpUXzcuHGRM2dO1KpVCzly5Ah3JKY23M2ePVvfYNy5c0dP+a9Zs0aXC/kB/744FXvo0CEsW7ZMr13fvXsXMWLEQNq0aVGyZElUqlQJbm5ub9XlfUJXH+RqDVWNSM+fP48bN27o8smTJ0fhwoU1tzc/3NevXw8fH5934kyVKpXeYKWO8G4mJNgq/jNmzMCePXs0E3XjljdvXn3uNGnSGG52xaB06dJ6SUZx8fb2fitHyDbLkCEDZs6cqTce3r9/H/HixdPsmjZtqjddvnmELGu07hFdQ1ft3LlzZ93/FJPx48cjWbJkoaqm9guofQPOuOxkuBOwgAgBCl0EI5OoNfH+/ftrEGp3e4oUKSIERcm7Q4cO+sP6XUeLFi3w/fffv/ODu2rVqroOz58/D45Rwvzpp59CCf19cWo38siRI7F48eJ31iN79uyYMGHCWzMR75OAmmYNkm9YiZWcpk6dik8++ST411JCl2Crdmgrto8fP36r+rFixcKcOXP0DY+RQ7VLnz59dDk1sxPWESRltc6uzu/n5/dWmNpcOWXKFCjhhzyCykak7hERurpBadOmDc6dO6ef6FD9KKyblFmzZmHixIl6j4nqRzxIwCwBCt0sQZbXBEaPHo0FCxZAfairEWhEj969e+uRuaurK3744QeUKVNGj8AuXryISZMm6RGNOoYPH46iRYuG+cGtfpgyZUo9U6BGjm9O/Qd9wL8vTo0A1flixoypR83fffedHmE9fPhQj7rUiOv27dt6pD5gwIBQ9XifBFS5Bw8eoHjx4rqOiRIlwn///Ydjx45h8uTJetSeKVMmLFy48C2EZjfFSbJVo8pPP/1Uz1gcOHBA70pXo/XPP/8cY8eONdT8ffv21ZJWMzyqju8TuvqdYqbW25UI1ah+3759uj/cvHlTM1UzKqpeQceb7W2k7kaF/tdff2mZq1kh1WfUjUpYsziqbuqmVeX38PDA9u3b9WOdPEjADAEK3Qw9lg0moD641EhLSU9Nl0fkUDucgx7HCmvaXq03queUg6YxV6xYEabQ3d3d9Sj4zSnONz/g3xV37949fSOhRvhq5KTE8eahnq2vXbu23gCorjfkucKb9n4XGyVENQJVglc3R28+p29G6FJs1dKH4q5uskIeGzduRPfu3bWUdu3a9U6JhXXtDRo00Dc0ag9G48aN3yt0JXA1a/LmM+rqRkg986/6iFqeUO85eLO9I1J3I0JX71zo2rUr1DsY1DW1atVK33C867h27VrwfgH1t6NmkXiQgBkCFLoZeiwrKnQ1Kh01ahTix4+vR+lKuG8ehw8fDp5uV2viakT25ge3Wtvu2bPnO1snaMT2rrigHcjvGikHJQ4SUb9+/fQacNARUaGr8upGRs1wKDFUq1Yt1DWYEboUW/WIoRrhvnmotexixYrpHxtdclEjc7UHQ72TQC2DhHUEtZmalVGj8bCOHj164Ndff8VXX32l+9Gb/SIidbdV6GoJImi3uroO1bfCO9Q6u6qrOvj4Wni0+HtbCFDotlBiTLgEJKbc1dT1jz/+qB95U9PdYR1qRKw2QKn/qnN++eWXb31wq+lYtV76riNIDu+KU9PHQaP/aNGi6TRqTT3kf0PmVlOs9evXD/5ReEJXMwzqZkQ9h6+mZp89e/ZWVdUGL7XkEPIwI3Qptu/bhZ4vXz49QlZT3iH3AITXedSNgLohUHswSpUq9V6hq1GvejQyrEPNaqg+8dFHH+n3HLwp9IjU3RahZ82aFSdOnNBT50OHDtX905ZD9Sm1JKSOd80E2ZKHMSQQRIBCZ18QISCxKU5N2aqpWzXdrdZV33WoUZpah35TALY+nhReXFA9bAXz5lTx+yQQdOMTXm51g6BuFKSE7gi2QUJfunQp0qVLF94lBv9eTY9fuXIlzFkJI1JWo3M1Sk+QIIHuR2+Wfd+rX99Vd1uErvZoqNG22mE/bdq0ULNG74MQcoQ+b948qBsDHiRghgCFboYeywYTkHhsTWoUGd47u8MTelA9IvpqzndJQD36pkbZ6qhcubJeP1VLBkoIQRui1Gtdf/nlFz3ilxS6I9hGVOhqxH306FG9QaxJkyZh/lUFtZmZEbq9hK428qmbCbU5Tz1yqDY32rLTP+TfDNfQ+WEqQYBCl6DIHJpAkMgi+mKZoClTW9fQ1ayAml41MhJTseEJXY0whw0bpj+c1Vq+0d3H7xK6Gr2pR9LUNKv6b1hH0CtBwxK6elRP7SGIyLvcHcE2okJXexDUEoS6wVHT4mEdEmvo9hK6yvv111/rPQA7duzQ70xQj6OpPRjvO7jLnR+c0gQodGmiUTifWhNW0rH11a9btmzRzzMHvfr10qVLwZuJ3rXLvXXr1vrbuNS7vtU7v0Me4YnaVvGr982rOvn7++t1bLWebeR4l9DVI2vqOe13PdqldkkHjcrDEroane7du/e9L+5517kdwTaiQlc3TWqUq17A8uaTC2+2mdo1rr6J7c0pffVYo9pQp9bw37zhsaVfmJlyD7pRUP0+aLSuZl1Ue6tH+9518Dl0I39VjLWFAIVuCyXG2ExAbYhSG4PUod7Oph7tKlSoUPDXRCpZHjx4UG9+C+vLWdQjR+pFKuo5dCWnsmXL6hGP+sBWU5lqBKQOdQ71LLc9hK5yqveJq5eUqEM9T6weJ1MvLFHPFKuNbOrlIUquqj7qmkMe75KquoFRX6mqDrXurm4a1MtQ/vnnH33NahQd9MKUsISuZg3U7IF6nE29oEa9vOfN2YP3rfnam21Eha76hHqeXx3qeez3vSlOxai1arWhsUCBArqM2mSodr6rNlFLGIqRen+ArTdwKk5C6CqPuqFQglf9W22SU3smVO6wDr4pzuaPFQbaSIBCtxEUw2wnsGnTJv0Ij9q5/L5DrVGracrYsWMHh6kRu3osSr1y9V3Hu0bNtozEVE5b4tQO5HHjxkFtVnrfoXbBv/lWu3dJVX3Yq7qrG5qwDjVCVUJSL88JS+hqJ7X6edCO+6Actr761d5sIyp0dR3q7X9qDVqNcINeIRySUVCbqb0H6rE4NXvy5qFuBNRN35vP79vS3lJCD6qTejvcokWL9KOX6kuK3tz5HvQud/UqXjVDoV6Ww4MEzBKg0M0SZPkwCajXjKoPXvWSEfUSFiV3NZpUo3a1hqxeIJMxY8Ywy6qpS1VWjVpVWfWiDjVKV+/hVo+j5cqVK8xytnxw2yr0oBOcPn1aTwOrr3xVI0klU7W2rl4ko0aIau30za/6fN8oWb2sRk27b9iwQY/M1Qe+GmmrR7fU+rl6ZE69qCYsoas6qWn5+fPnQ72RTL21TtXHVqGr8vZka0bo4X3bWsi2VdPt6l3yqk3U0w6qbwS9y131rzcPW/qFtNBVHdSjl+qNg6rfq1F70HP66ndB7zpQP1MzLzxIQIIAhS5BkTlIgARMEVAjVbUGrtb6w/o+dFukbKoCDi4ctPlR3dyp7wTgQQISBCh0CYrMQQIkYJqAWmpQ68rffvutnqkIeTiT0NWbANWmz7Cu0zREJojSBCj0KN38vHgSiFwE1Lv61VMM6n3tIb81zVmErpZI1LKRere+mnYPa4kgcrUIa/MhEaDQP6TWYl1JIIoScBahR9Hm42U7iACF7iDQPA0JkEDECVDoEWfHklGHAIUeddqaV0oCJEACJODEBCh0J25cXhoJkAAJkEDUIUChR5225pWSAAmQAAk4MQEK3Ykbl5dGAiRAAiQQdQhQ6FGnrXmlJEACJEACTkyAQnfixuWlkQAJkAAJRB0CFHrUaWteKQmQAAmQgBMToNCduHF5aSRAAiRAAlGHAIUeddqaV0oCJEACJODEBCh0J25cXhoJkAAJkEDUIUChR5225pWSAAmQAAk4MQEK3Ykbl5dGAiRAAiQQdQhQ6FGnrXmlJEACJEACTkyAQnfixuWlkQAJkAAJRB0CFHrUaWteKQmQAAmQgBMToNCduHF5aSRAAiRAAlGHAIUeddqaV0oCJEACJODEBCh0J25cXhoJkAAJkEDUIUChR5225pWSAAmQAAk4MQEK3Ykbl5dGAiRAAiQQdQhQ6FGnrXmlJEACJEACTkyAQnfixuWlkQAJkAAJRB0CFHrUaWteKQmQAAmQgBMToNCduHF5aSRAAiRAAlGHAIUeddqaV0oCJEACJODEBCh0J25cXhoJkAAJkEDUIUChR5225pWSAAmQAAk4MQEK3Ykbl5dGAiRAAiQQdQhQ6FGnrXmlJEACJEACTkyAQnfixuWlkQAJkAAJRB0CFHrUaWteKQmQAAmQgBMToNCduHF5aSRAAiRAAlGHAIUeddqaV0oCJEACJODEBCh0J25cXhoJkAAJkEDUIUChR5225pWSAAmQAAk4MQEK3Ykbl5dGAiRAAiQQdQhQ6FGnrXmlJEACJEACTkyAQnfixg15aXfPjIz0V+qdrHykr6Ou4LnBkb6eDz2zRPo6qgrGTlE10tfzycUpkb6OqoJxFq2M/PUc8Ffkr+MHXEMK/QNuPCNVp9CN0AonlkIXg0mhi6Gk0OVQfrCZKPQPtumMVZxCN8brvdEUuhhMCl0MJYUuh/KDzUShf7BNZ6ziFLoxXhS6IK/3pKLQ5Thzyl2O5YeaiUL/UFvOYL0pdIPA3hfOEboYTApdDCVH6HIoP9hMFPoH23TGKk6hG+PFEbogL47QHQKTI3SHYA4+yfwVG7F6wy6cuXAVlUt9Cd+ODRxbgTDORqFb3gSOqQCFLsiZI3QxmByhi6HkCF0OpU2ZNu44ADc3V2zYuh+eHjEodJuoMUiEAIUugvFVEgpdDCaFLoaSQpdDaSjTgDHzERAQQKEbosZgUwQodFP4Qhem0MVgUuhiKCl0OZSGMlHohnAxWIIAhS5B8f85KHQxmBS6GEoKXQ6loUwUuiFcDJYgQKFLUKTQBSnqVBS6HNEosymuVwY5aEYyDfg7zGgK3QaIS9dsxd4/T2JMv1Y2RIcfIpXvydNnyFeyGQ5unI4Y7m7hnziSRFDogg3BEboYTApdDGXUGaH7WCT0/lFM6OpOZfHqLaF6qEdMdxzYMM1wr5UScNCJpfJR6Iab0uYCfJe7zajCDeS73MNFZHMA3+VuM6rwAyXe5d47ffjnsUdEvzOhsr4ICEBAwEsMmbBIb4rr2bYuXF2jIbqrqz3OblNO0cfWlNCfPnuO3h3qB5/cBYB7BEayUgJWFVHgV67bITLip9Bt6lcRCqLQI4QtzEIUuhxLCl2OJSSE7muR0PuGFvrYGSsxbcFPoeB8X7MUOvxQTRCYsVTiQn/u54/+XRqFWYsvK7ZB8/rlMW/5Rty++y+qlf0adauWQNcBU3Dy74vInyszRvRuoZ/pU0L/bd9ReHt5Yuuug0iaOAF8O9RHnk9fTbf8uv0PTJq7Gv/cuIO4cbzRsHpJ1KpYTP9Old225xDixPbC8dMXULfKt1A3FkFT+OquqtfQmXjw8BFG922Fh4+eYNC4Bdh/6DRixnTX8fWrltC5AgMDMX7WKixbux0xY7jhh3rl0GfEHE65G+tnNkVT6DZhsimIQrcJk01BFLpNmGwLciKh23bBjo1yuNDTp0mJEb7N8ejxU1Rt2gdpP06mn9/7KHkiNOk0At99nV8LVUl5wNj5GNStCUoVK4Bftu7T0t24ZAS8Ynlg9x/HkSxJAqT5KKmW9vcdh2H26G7ImjG1Ltt/zHzMHt0V+XJm0lJetnabFvqwXj+gU//JcHdzw+AeTRHdNRpqtxyAXNnSo03jyrh77wEadxqOri1r4auCObB2425MmrMGs0Z1Qdw4XujUbzJ27D1Coduhn1LoclApdDmWFLocS5ERep90ghUykKrPWQPB1oSKC33Fzzv0CDvoyJYxDaYN76T/qUboQ3v+gIJ5s+p/t+wxBhnSfoS2jSvrf89ZtgF/n7uCQd2baCkvXbsNq2b2D85VuXFvNK1TBiWK5H+LVo/B05E5fargm4E1v+7Gokk+wXEq39bdh/T0e8pkieDboQGiRXPB6bOXUa/NIOz9aZJe/1DHwlWbcOKvi7oezbqOROF82XVedRw7fQE1mvWl0O3QXyl0OagUuhxLCl2OpYjQ+1okdN8oKHQ1jd2xWfXgHqBGwvHjegcLfeaoLlCjdHV07DsJubNnQO1KxfW/Q66bq//f8fsRTBrcPjhX617jkD9nJi3XIyfPYdzMlbh05Yb+/YOHT1C3yjdo831lnWfPgRMY2791KKGPn/Ujnvv5Yc3sgUieNKH+nZJ8hz4TkeL//1Y/8/d/gUzpP8a4/m1Q6XsftGpUCUUL59Lx9x88QuHyrSh0wb/xoFQUuhxUCl2OJYUux1JE6P0+EayQgVS9zxkItiZUfIQe3hq6EaG/OUKv0sQXTWqX1iP0olXbo0PTano6Xo201Zp4ogRx9Wg/rA11QT/LmyMjFqzchLljuyNJong4deYSfugyEjtWjYWLi1ppD32oEXqxL/Kgapki+hfnLl5DuQY9KXQ79FcKXQ4qhS7HkkKXYyki9P4WCd0nCgr9zV3uqisEPa+tptyNCF2toat17lJFC2DDtv3oP3pu8Bp6/lLNsWBCT2T85CNcu3EHVZv6onq5ouEKXT3XPmfpBiz7aZuWeoJ4cVC71QC92a5F/fKI4e6Oi1eu48nT58ieOa3+Np0lq7dgztjuiBnDHb4jZmPFuh0UuuDfOEfo8jApdDmmFLocSxGhD7BI6L2ioNDffA5ddYW96yYhtpenXkM3IvRQu9wTxYdP+3p6k5s61m3eiynz1iJxgrh6ZK62sSdPktAmoavy0xeug1pnnzOmm843fNIS7P3zBPz8XyD1R0nRulElFM6XDS9fBuqpfTU1nyhBHD31PmjcQgpd8G+cQpeHSaHLMaXQ5ViKCH1gWsEKGUjV87yBYGtCRafcrbkEntUWAnxTnC2UbIzhm+JsBBV+GN8UFz4jWyOizKtfKfR3dgkK3da/lg88jkIXbEAKXQwmhS6GMuq8+nVQGjloRjL1uGAk2pJYCt0S7I4/KYUuyJxCF4NJoYuhjDpCH2yR0LtT6HK9lZlMEaDQTeELXZhCF4NJoYuhjDpCH5JaDpqRTN0uGom2JJYjdEuwO/6kFLogcwpdDCaFLoYy6gh9qEVC70qhy/VWZjJFgEI3hY8jdEF8IVNR6HJgo8ymuGEWCb0LhS7XW5nJFAEK3RQ+Cl0QH4VuH5hRRujDU9kHYHhZO18KL8Ly33PK3fImcEwFKHRBzpxyF4PJEboYyqgz5U6hv7PTUOhyf0+ROhOFLtg8FLoYTApdDGXUEfqIj+WgGcnU6bKRaEtiKXRLsDv+pBS6IHMKXQwmhS6GMuoIfaRFQu9Iocv1VmYyRYBCN4WPa+iC+LiGbh+YUWYNfdRH9gEYXtYOV8KLsPz3HKFb3gSOqQCFLsiZI3QxmByhi6GMOiP00RYJvT2FLtdbmckUAQrdFD6O0AXxcYRuH5hRZoQ+xiKht6PQ7dNzI1FWv0dnI1Ft3l2VwCNFI309YxSO/GtUCuLToy0jPcuYL+5E+jqqCr6I5hnp6+m2Yk+kr6Oq4INalSN9PeNkGWS+jmNTms8RkQxtr0aklEPLcMrdJG4K3STAEMUpdDmWFLocSwpdjiWFLscyrEwUukm+FLpJgBS6HMAQmSh0OawUuhxLEaGPSyFXISOZ2lwzEm1JLIVuEjuFbhIghS4HkEK3C0sKXQ6riNDHWyT01hS6XE+IpJkodLmG4ZS7HEuO0OVYUuhyLEWEPsEiobei0OV6QiTNRKHLNQyFLseSQpdjSaHLsRQR+sTkchUykqnlP0aiLYnllLtJ7BS6SYCccpcDyCl3u7Ck0OWwigh9kkVCb0Ghy/WESJqJQpdrGI7Q5VhyhC7HkkKXYyki9MnJ5CpkJFPz60aiLYnlCN0kdgrdJECO0OUAcoRuF5YUuhxWCl2OZViZKHSTfCl0kwApdDmAFLpdWFLoclhFhD4lqVyFjGRqdsNItCWxFLpJ7BS6SYAUuhxACt0uLCl0OawiQp9qkdB/oNDlekIkzUShyzUM19DlWHINXY4lhS7HUkTo0ywSelMKXa4nmMz05OlzfFmxNfLmyIgpQzuazPa6OIUuhhIUuhxLCl2OJYUux1JE6NOTyFXISKYmN41EWxIbZabcV2/YhWETF+Ph4yfYunw0EiWIKwKcQhfBqJNQ6HIsKXQ5lhS6HEsRoc+wSOiNKXS5nmAyU8P2Q5AjSzrs3HcUZYoXRMMaJYMznrlwFb2GzMSFK9eR59OMSBg/DuLF8UKHH6rpmLUbd2P6gnW4fe8BsmZMjX6dGyFF0oT6dxS6yYYJUZxCl2NJocuxpNDlWIoIfWZiuQoZyfT9LSPRlsRGiRH69Zt3Ubx6R6ydMxA79x2DGq2vnj1AAw8IeIky9bqhermiqFvlW/x59G806zoSdSp/o4W+a/8x+AybiclDOiBdmhSYv3wjNmzbjyVTesPFxYVCF+y2FLocTApdjiWFLseSQpdjGVamKCH0KfPWYuOOP7BqZn/cunMfRau2x/JpfZA5fSocO3UeLbqPxo5V4xAtmotm1LrnWKT5OJkWeute45ArWzo0qlFK/y4wMBCfV2iNZVP76FE6R+hyHZRCl2NJocuxpNDlWIoIfVYiuQoZydTotpFoS2KjhNBL1u6KqmW/Cpaymn7PkPYjdG9dG1t2HsSkuauxcka/4AYYOHY+PGLG0EKv3Lg37t3/D54eMYN///DRE4wf2BY5snxCoQt2WwpdDiaFLseSQpdjKSL02RYJvSGFLtcTIpjp0PEzqNNqIGJ7ecLNLbrO8vjJM3h6xMC2lWNw8q+LaNljzDtH6K16jEXh/NlQs0KxMGvAEXoEGyaMYhS6HEsKXY4lhS7HUkTocywSegMKXa4nRDBTnxFzcPXGbQzp0TQ4w7PnfqjYqBeG+TTDF599ijJ1u6NG+bDX0NUmur4j52BM/9bImiE1Hj1+ij0HjqNEkfw6H4UewYah0OXAhZGJQpfDS6HLsRQR+txXG5IdftS/4/BTGj2hU0+5P/fzx1eV2mJwjyb4ulCuUGz6jZ6He//+hzH9WuH02cvoPXwWLly+oZ9TVzvckydJiFaNKuoy67fsw7QFP+HajTvw9vJA/lyZg28QKHSjXe7d8Ryhy7Gk0OVYUuhyLEWEPs8iodej0OV6ggMzqSn4IoVyomqZIuGelUIPF5HNARS6zajCDaTQw0VkcwCFbjOqcANFhD4/QbjnsUtA3buh0qqlWzUQ3L7nMGJ7e6JZ3XKoXr5omKdWsf1Gz9WPTasnqz7LnRm929fXj0hLHk49QrcV1MFjfyNVyqSIH9dbP6bW3ncC1s0fgqSJ4oebgkIPF5HNAcq4N+cAACAASURBVBS6zajCDaTQw0VkcwCFbjOqcAOdSehK5lf+uYWRvi1x4fJ1/bizegtpnk8zvMVh6MTFOHDkL0wc1A4xYrih28Bp8I7loZd9JQ8KHcCKdTswbuZK+Pm/QOKE8dCuSRUULRx6iv5d0Cl0ue5IocuxpNDlWFLocixFhL7AohF6ndcjdP8XAShYprkWuFqmVYfPsFn6v/27NHoLmHr8WT0m3aJ+ef27dZv2YtaS9fpRasmDQjdJk0I3CTBEcQpdjiWFLseSQpdjKSL0heHPnMrVOESm2veC/3Hp6k2UqtMV+36eDK9YHvrnC1dtxrrNe7F4ks9bp9/9x3FMnrsGo/u2hLv7qxF6xk8+0oNHyYNCN0mTQjcJkEKXAxgiE4Uuh5VCl2MpIvRFFgm91muhnzpzCVWa+OL4ttn6jaHqUK8In7FovX4j6ZvH3X//Q4/B0/WSrjrUO0xmjOwc6v0mEpQpdJMUKXSTACl0OYAUul1YUuhyWCWEHrg4nlyFDGRyqflvhEfoP3QZqUfm/To3hLubG0ZNXYaLV25g5qguBmoQfiiFHj6j90ZQ6CYBUuhyACl0u7Ck0OWwOovQ1Rp6gdLNMX1EJ+TO/moTnNokFxgY9hr611XawbdDA/30lDrUF4JVaNgLhzfPhFt0VzHAFLpJlBS6SYAUuhxACt0uLCl0OawiQl9i0Qi9xusRuiKiNsFdv3UXI31b6NF2k07D9Zd4qV3u6gvBFqzchI7NquvvCGnrM15Pzffr0ghu0aNj1NSl2HfwFNbOHSQHFwCFbhInhW4SIIUuB5BCtwtLCl0Oq4zQ48pVyEAmlxr3Q0WrZ8uV1HfsPaw3xqkd7EHPoR85eQ61WvTHkS0zEd3VFXfuPYD6jpB9h07p59CzZEiF7q3rIEPalAZqEH4ohR4+o/dGUOgmAVLocgApdLuwpNDlsIoIfalFQq8eWuhyVOQyUegmWVLoJgFS6HIAKXS7sKTQ5bBKCP2lRUKPRqHLdYTImolCl2sZPocux5KPrcmxpNDlWIoIfZns61Jtvbpo1R7YGmpZHEfoJtFT6CYBcoQuB5AjdLuwpNDlsFLocizDykShm+R79/QAkxkcUzz2/eWOOZGJszxO1s5EaccVjXN3g+NOFsEzvfA7HcGSji3mtu6ZY08YgbP5VykUgVIWFMnQ14KTGjulm+fHxgqEEf1yuUUj9KocoZtuvMiegEKXayEKXY4lhS7HkkKXYykh9IDlseUqZCCTa9X/DERbE8oRuknuFLpJgCGKU+hyLCl0OZYUuhxLEaGvsEjoVSh0uZ4QSTNR6HINQ6HLsaTQ5VhS6HIsKXQ5lmFl4gjdJF8K3SRAjtDlAIbIRKHLYaXQ5ViKCH2lt1yFDGRyrfzQQLQ1oRS6Se4UukmAFLocQArdLiwpdDmsIkJfZZHQK1Hocj0hkmai0OUahlPuciw5QpdjSaHLsZQQ+guLhB6dQpfrCJE1E4Uu1zIUuhxLCl2OJYUux1JE6D96yVXIQKboFR8ZiLYmlFPuJrlT6CYBcspdDiCn3O3CkkKXw0qhy7EMKxOFbpIvhW4SIIUuB5BCtwtLCl0Oq4jQV1s0Qq/AEbpcT4ikmSh0uYbhlLscS065y7Gk0OVYSgjdf3UsuQoZyORW4bGBaGtCnXKEfu3GHZRv0AMHNkzTVDv2nYTc2TOgdqXi4pQpdDmkFLocSwpdjiWFLsdSROhrLBJ6eQpdrie8ken23fsYPH4R9h06iWfP/JAyeSLUKF8UNSsUg/ri+Z+3/I5qZYvYJPQ1v+7GjIXrcPXGHXjH8kDWjGnQv0sjJIwf/juDKXS5JqbQ5VhS6HIsKXQ5lhS6HMuwMn2wI/RmXUfBI6Y7urWqDW8vT5y9cBX/3LyL777O/9Z1vm+EfuzUeTRsPwSj+rTEZ7mz4MF/j7H7j2MonC87EieMGy59Cj1cRDYHUOg2owo3kEIPF5HNARS6zajCDRQR+lrPcM9jjwC3ck/skVY05wcr9C8rtsHAbk3wxWfZ3wIS1pR7siQJcOjYGZy5cBXZM6fFoG5NkCRRPCxdsxU/btiFJZN7hwlW/X7LroP6puHS1ZsIDAxEjzZ1kOfTDDqeQpfrjxS6HEsKXY4lhS7HkkKXY+lUI/S2PuP1iPz7mqWQI8snUMIOOsIS+r6DpzBjZGd8kio5Bk9YhEtXbmDmqC44ffYyajTri0Y1S+GrgjmRKd3HiOHuFpxLCb3f6HmYP76HXoc/eOwMWvUcg42LR8ArlgeFLtg/KXQ5mBS6HEsKXY6lhND9frJmhO5eliN0uZ7wRqYnT59j3vJfsXnnnzhz/irSfJwMvdrVRd4cGRGW0NV6ePfWtXWWh4+eoECZFti5ejzix/XGwWN/Y8HKTThw5C88efoMFb77Al1a1IC7u9urEfwvO7Fkim9wDWq26I8G1UqgRJH8FLpgC1PocjApdDmWFLocSxmhe8hVyEAm97JPDURbE/rBTrmHxKUkPGXeWiz/aTu2rhiDe/f/e2uXe/ZMadGg+nfBxZTQ54zppkfkIY8Tf11EW59xqF6+KJrULqOF/tu+o5g4qF1wWOte45A/ZybUrfIthS7Ybyl0OZgUuhxLCl2OpYjQ11kk9DIUulxPCCfTvfsP8UWF1lg3b7AeWb/52FpYI/TffhyHBPHe/m7d/qPn4cHDxxjRu7kW+qLVW7Bm9sDgGlRs1AvN6pXjCF24dSl0OaAUuhxLCl2OpYzQY8pVyEAm9zLPDERbE/rBjtCHT1qCEkXyIV2aFHju549pC9bhp417sG3FaNy6e/8toe8/pNbQuyBtquQYOmERzl26htmju2H7nsO4fe8+Ps//KRLE9cbJM5fQ3ncCGlYviXpVS2ihDxg7H/27fI9y3xbGus17MGjcQmxaMkJvlOOmOLmOS6HLsaTQ5VhS6HIsJYT+/GdrhB6jNIUu1xPeyDR2xkq9+/za9dtwd4uOLBlTo0PTasiaMXWYa+ihdrlnSosB3RojWeL4OP7XBUyasxrq8bWHj58iScJ4KPNNQbRsUBHRorlooe/cdwxeXh7YuusgkiaKD5/29ZAvZyZdIwpdrokpdDmWFLocSwpdjiWFLscyrEwf7AjdvlheZ1dC3/vnSYzp1yrMU1Loci1BocuxpNDlWFLocixFhL4+hlyFDGSKUeq5gWhrQin0cLhT6I7rmBS6HGsKXY4lhS7HkkKXY8kRegRYUugRgBbBIhR6BMGFUYxCl2NJocuxFBH6LxaN0EtyhC7XEyJpJk65yzUMhS7HkkKXY0mhy7GUEPqzX9zlKmQgU8ySfgairQnllLtJ7hS6SYAhilPociwpdDmWFLocSxGhb7BI6N9R6HI9IZJmotDlGoZCl2NJocuxpNDlWFLociy5hm4HlhS6HFQKXY4lhS7HkkKXYyki9F9ff9eGXM3CzxSzhH/4QRZHcMrdZANQ6CYBcspdDmCITBS6HFYKXY6lhNCfWiR0DwpdriNE1kwUulzLcIQux5JCl2NJocuxFBH6RmtG6B7fcoQu1xMiaSYKXa5hKHQ5lhS6HEsKXY6liNA3RZerkIFMHt+8MBBtTSin3E1yp9BNAuSUuxxATrnbhSWFLoeVQpdjGVYmCt0kXwrdJEAKXQ4ghW4XlhS6HFYRoW+2aIRenCN0uZ4QSTMFHqweSWv24VXrv0TlPohKBz46HenrGXfhskhfR1VB/zLWfHOWETjR3V99EVNkP+5554/sVUSC9B1N1/HJZlfTOSKSwLN4QESKObQMR+gmcVPoJgGGKE6hy7Gk0OVYUuhyLEWEvsUioRej0OV6QiTNRKHLNQyFLseSQpdjSaHLsaTQ5ViGlYkjdJN8KXSTADlClwMYIhOFLoeVQpdjKSL0rdHkKmQgk2fRlwairQml0E1yp9BNAqTQ5QBS6HZhSaHLYZUQ+mOLhB7rDaE/fvIMvYfPwvY9hxHb2xPN6pZD9fJF3wnr2KnzGDJhEU78fRFxvGOhVaOKqFqmiBxcABS6SZwUukmAFLocQArdLiwpdDmsIkLfZs0IPdbXoUfoSuZX/rmFkb4tceHydTTrOhJThnZEnk8zvAXs9t37KFe/B1o2rIhvvsyLp8+e49GTp8iWMY0cXArdPEsK3TzDoAxcQ5djySl3OZYUuhxLGaG7yFXIQKZYXwcGR/u/CEDBMs21wPPmyKh/7jNslv5v/y6N3so6dOJiPPjvEQZ1b2LgjMZDOUI3zixUCQrdJECO0OUAcoRuF5YUuhxWEaFvt0joRV4L/dLVmyhVpyv2/TwZXrE8NKCFqzZj3ea9WDzJ5y1gtVr0R65s6bHrj2O4dftf5MqeHj7t6yNZ4vhycDlCN8+SQjfPkCN0OYZBmThCl2NKocuxdBahnzpzCVWa+OL4ttlwcXl1g7F2427MWLQea+cMfAtYsaod4Ofvj2nDOyFVyiToO2ourt+8i3njesjBpdDNs6TQzTOk0OUYUujyLCl0OaYiQt9h0Qj9q4iP0NVo/ssCOdCtVS0N8/K1WyhZuwv++GUKPD3kXq7EKXeTfZVCNwmQU+5yADnlbheWFLocVhmhW/NimVhfvX6xjFpDL1C6OaaP6ITc2V9tglOb5AIDw15Db+87AUkTJ0DXljUpdLnuZDzT0jVbsffPkxjTr1WYhSl040zfVYKb4uRYcspdjiWFLsdSRujWfH1qrK9Cf32q2gR3/dZdjPRtgYtXbqBJp+GYPKSD3uWuptMXrNyEjs2qI1o0F/z2+xH0HDIDs0Z3xUfJE6PfqLn45+ZdzBnTTQ7uhz7lXq5BT5y7eE0DiRvHC4XyZkXPNnX1/0sdFLoUyfDzUOjhM7I1gkK3lVT4cRR6+IxsjZARurutpxONi/WVX6h86jl0JfUdew/rjXEt6pcPfg79yMlzUBvhjmyZieiur2YU5q/YiBmLfsaz537IlyMTfNrXQ5JE8UTr+EFPuSuhf1+zFEoXL4Br1++gQ5+JyJ4pLfp0amAzpMDAQLx8GQhX17CfbaTQbUZpOpBCN40wOAGFLseSQpdjKSL03+TWnI1cWawvnxkJtyT2gxd6k1qlUfbbQhqeuvvZvPNPzB/XAx36TsKhY2fwIiAAObJ8gj4dGyBZkgQ6rmPfSUgQLw7OXLiCq9fvYOKgdnj27DmGT16CMxeuIWYMdzSrVw41yheFEvquP44jYfw4WLdpDxLGj6ufMwx69pBT7nL9lkKXY0mhy7Gk0OVYSgj9yW+echUykMnzyycGoq0JdRqhP3n6DC26j0HSxPHRr1NDbNi+H8W/yKsfKRg4dj7+ffBQiztI6EdOnMWiSb2ROGFc3Lz9L8rW744ebeqgdPGCULmu/nMbWTOm1kIfNG4hBvVogm+/yodla7fptZFfFg7VuSh0uY5LocuxpNDlWFLocixlhB5LrkIGMnl++dhAtDWhH7zQb96+hxjubvjv0RPkzJoOQ3v+8Na6xLUbd1C5cW/8vm5SsNDVxoR2Tarof89d/iv2/HEcU4e9/V29Suhrft2NRf9/WcBzP3/k/rZJ8OMGFLpcx6XQ5VhS6HIsKXQ5ljJC95arkIFMnl8+NBBtTegHL3Q1Lf7tV3n1y+7d3KJrigEBLzFu5kps2XVQj7Zd4IIbt+/h6JZZeq1cTbnnzp4etSt9o+PVa/n8/V+gV7u6b7VCWGvo2Ys2xLYVY/Q0PIUu13EpdDmWFLocSwpdjqWI0HfGkauQgUyeXzwwEG1N6Acv9JBr6EEIV6zbgRU/78Ckwe0RP663foSgePWOwTsOXwk9A2pXKm7TCP3Nx9YodPt0VgpdjiuFLseSQpdjKSH0pzvjylXIQCaPL+4biLYm1CmFPmfpBhw8/jfG9W+jqQ6ftARzlm14p9DVN+GUrtsNPu3q4buin721hk6hO6ZzUuhynCl0OZYUuhxLGaHLvv/c1qvz+OKeraGWxTml0B8+eoLO/Sfj9t0Helr8q4I59ca4oGcC3xyhK/qHT5zFsImLcfbiNf0qvub1Xn23LafcHdc3KXQ51hS6HEsKXY6ljNATylXIQCaPL+4YiLYm9IMWujXIQp+Va+hyrUChy7Gk0OVYUuhyLEWEviuRXIUMZPL4/LaBaGtCKXST3Cl0kwBDFKfQ5VhS6HIsKXQ5ljJCTyJXIQOZPD6/aSDamlAK3SR3Ct0kQApdDmCITBS6HFYKXY6lhNCf7UomVyEDmWJ+ft1AtDWhFLpJ7hS6SYAUuhxACt0uLCl0OawyQk8uVyEDmWJ+/o+BaGtCKXST3Cl0kwApdDmAFLpdWFLoclhlhJ5SrkIGMsX8/KqBaGtCKXST3Cl0kwApdDmAFLpdWFLoclhFhL77Y7kKGcgUs/BlA9HWhFLoJrlT6CYBUuhyACl0u7Ck0OWwSgj9+e5UchUykClG4UsGoq0JpdBNcqfQTQKk0OUAUuh2YUmhy2GVEXoauQoZyBSj8AUD0daEUugmuVPoJgFS6HIAKXS7sKTQ5bDKCP0TuQoZyBSj8DkD0daEUugmuVPoJgFS6HIAKXS7sKTQ5bCKCH1POrkKGcgUo9BZA9HWhFLoJrlT6CYBUuhyACl0u7Ck0OWwygg9g1yFDGSKUehvA9HWhFLoJrlT6CYBUuhyACl0u7Ck0OWwSgjdb08muQoZyORe6LSBaGtCKXST3Cl0kwApdDmAFLpdWFLoclhlhJ5ZrkIGMrkXOmUg2ppQCt0k90fHO5rM4Jji0R8sdsyJTJzlZcC/Jko7rqjnRmuegzVyhfdrVzMSbllsnKeRfxrzWXRrvt3LaKO4Bj4zWsTh8e45Zpo+p9/erKZzRCSBe8ETESnm0DIUukncFLpJgCGKU+hyLCl0OZYUuhxLGaFnk6uQgUzuBY8biLYmlEI3yZ1CNwmQQpcDGCIThS6HlUKXYykhdP+9n8pVyEAmt4JHDURbE0qhm+ROoZsESKHLAaTQ7cKSQpfDKiP0nHIVMpDJreBhA9HWhFLoJrlT6CYBUuhyACl0u7Ck0OWwigj991xyFTKQya3AIQPR1oRS6Ca5U+gmAVLocgApdLuwpNDlsMoIPY9chQxkcivwp4Foa0IpdJPcKXSTACl0OYAUul1YUuhyWGWEnk+uQgYyuRX4w0C0NaEUuknuFLpJgBS6HEAK3S4sKXQ5rBJCf/F7frkKGcgUvcB+A9HWhFLoJrlT6CYBUuhyACl0u7Ck0OWwigh9XwG5ChnIFP2z3w1EWxNKoZvkTqGbBEihywGk0O3CkkKXwyoj9EJyFTKQKfpnewxEWxNKoZvkTqGbBEihywGk0O3CkkKXwyoj9MJyFTKQKfpnuw1EWxNKoZvkTqGbBEihywGk0O3CkkKXwyoh9IB9X8hVyEAm1892Goi2JtRphf7vg4f4vHzrUFQ9YrrjwIZpoqQpdDmcfPWrHEu+KU6OJYUux1JE6Pu/kquQgUyu+XcYiLYm1OmF/svCYUiSKJ6m6wLA3d3NZtIvAgIQ3dX1vfEUus04ww2k0MNFZHMAhW4zqnADKfRwEdkcICP0IjafTzLQNf92yXR2yeX0Qt+yfBSSJoofDO/cxWvoM3IOzly4Brforij+ZV50b1UrWPRfVmyDelVL4Jet+/Dczx/r5g3G2o27MX3BOty+9wBZM6ZGv86NkCLpq29gotDl+iWFLseSQpdjSaHLsZQRelG5ChnI5Jp/q4Foa0KjnNDPXriGe/cfIlf29Pj3/kO06D4aZb4piAbVvtMtoISeJUNqjOvfGm5u0bH7j+PwGTYTk4d0QLo0KTB/+UZs2LYfS6b0houLC4Uu2G8pdDmYFLocSwpdjqWM0IvLVchAJtf8mw1EWxPq9EKP7eUJl2hqsh2oUvordPgh9PdE//jLTmzdfQjjB7QJFvrgHk1RON+rr+hr3WsccmVLh0Y1Sul/BwYG4vMKrbFsah89SucIXa7jUuhyLCl0OZYUuhxLCaG/3P+NXIUMZIqWf5OBaGtCnV7oS6f6ImH8OJqup0dM+Pn5Y9jExTh66jz8/V/oafU0HyfF/PE9g4U+Y2QXZEibUv+7cuPeuHf/P1026Hj46AnGD2yLHFk+odAF+y2FLgeTQpdjSaHLsRQR+h8l5CpkIFO0fL8aiLYm1OmF/uYaetcBU+Ht5YlOzasjZgx3rPl1N5b/tB0LJrwW+sxRXZA+zSuht+oxFoXzZ0PNCsXCbCGO0OU6LoUux5JCl2NJocuxlBF6SbkKGcgULd8vBqKtCY1yQldr5oXyZkOdyt/g6TM/NO08Qk+jv0voO/cdRd+RczCmf2tkzZAajx4/xZ4Dx1GiyKv3CVPoch2XQpdjSaHLsaTQ5VjKCP3V8qejj2j51jv6lIbPF+WEfvrsZfQcMgOeHjHgFctTS/r3gyffKXRFdP2WfZi24Cdcu3EH3l4eyJ8rM4b0aEqhG+5u7y9AocsBpdDlWFLociwlhB74Rxm5ChnI5JJvXajox0+eoffwWdi+5zBie3uiWd1yqF7+/Tvw1aPQVRr74uLVGzi8aYaBs9sW6rRCt+3yzUdxhG6eYVAGCl2OJYUux5JCl2MpIvQD5eQqZCCTS961oaKVzK/8cwsjfVviwuXraNZ1JKYM7Yg8n2Z4Z9Y5Szdgy66DOHb6PIVugL3DQil0OdQUuhxLCl2OJYUux1JG6OXlKmQgk0veNcHR/i8CULBMcy3wvDky6p/7DJul/9u/S6Mws964fQ+N2g9Fr3Z10aL7GArdAHuHhVLocqgpdDmWFLocSwpdjqWM0CvKVchAJpe8PwZHX7p6E6XqdMW+nyfDK5aH/vnCVZuxbvNeLJ7kE2bWtj7j8W2RfEiZLBHqtx1MoRtg77BQCl0ONYUux5JCl2NJocuxlBF6ZbkKGcjkkndlcPSpM5dQpYkvjm+brV8wpg71RtEZi9Zj7ZyBb2VVm6tnLl6POWO64cjJcxS6Ae4ODaXQ5XBT6HIsKXQ5lhS6HEsRof9ZRa5CBjK55FkRoRG6etdJpe99MLZfa/22UQrdAHRHh1LocsQpdDmWFLocSwpdjqWM0KvKVchAJpc8y4Oj1Rp6gdLNMX1EJ+TO/moTnNokFxj49hr6+cvXUaFhT8SN7aXjXrwIwIOHj5EgXmxMGdpBv2pc6uAud5MkKXSTAEMUp9DlWFLociwpdDmWMkIP/fpuudq9P5NLnmWhAtQmuOu37mKkbwtcvHIDTToN19/5oXa5X795FwtWbkLHZtX1e07U13kHHSf/vog2PuOxeelIxIntpb8kTOqg0E2SpNBNAqTQ5QCGyEShy2Gl0OVYSgj95Z/V5SpkIFO0PEtDRavn0JXUd+w9rDfGtahfPvg5dDWtXqtFfxzZMvOtr+DmlLsB6I4OpdDliHOELseSQpdjSaHLsRQR+sEachUykCla7iUGoq0J5QjdJHcK3SRAjtDlAHKEbheWFLocVgmhBxysKVchA5lccy82EG1NKIVukjuFbhIghS4HkEK3C0sKXQ6rjNBryVXIQCbX3IsMRFsTSqGb5E6hmwRIocsBpNDtwpJCl8MqI/TachUykMk190ID0daEUugmuVPoJgFS6HIAKXS7sKTQ5bBKCP3FoTpyFTKQKXquBQairQml0E1yf7zj1VuCIvsRzV/u0Qh7XavH9k/slVo075NvL4vms0cy/zTy3+Rkj3oGvvSzR1rRnHFTNRTNZ69kfo/O2iu1WF53r3Smc704VNd0jogkiJ5rfkSKObQMhW4SN4VuEmCI4hS6HEsKXY4lhS7HUkLo/ofqyVXIQCa3XPMMRFsTSqGb5E6hmwRIocsBDJGJQpfDSqHLsZQRen25ChnI5JZrroFoa0IpdJPcKXSTACl0OYAUul1YUuhyWEWEfriBXIUMZHLLOcdAtDWhFLpJ7hS6SYAUuhxACt0uLCl0OawSQvc7bM2eBvecs+VA2CkThW4SLIVuEiCFLgeQQrcLSwpdDquM0BvJVchAJvecswxEWxNKoZvkTqGbBEihywGk0O3CkkKXwyoh9OeHv5erkIFMMXLONBBtTSiFbpI7hW4SIIUuB5BCtwtLCl0Oq4zQG8tVyECmGDkj/6OgFLqBBg0rlEI3CZBClwNIoduFJYUuh1VE6EeayFXIQKYYOaYbiLYmlEI3yZ1CNwmQQpcDSKHbhSWFLodVQujPjjSVq5CBTDFzTDMQbU0ohW6SO4VuEiCFLgeQQrcLSwpdDquM0H+Qq5CBTDFzTDUQbU2o0wr9x192YuOOA5g8pL0o2SdPnyFfyWY4uHE6Yri7gUKXw8s3xcmx5Itl5FhS6HIsJYT+9EgzuQoZyOSRY4qBaGtCHSr023fvY/D4Rdh36CSePfNDyuSJUKN8UdSsUEz86s9fvo4r127hq4I5RHNT6KI4QyWj0OXYUuhyLCl0OZYiQj/aXK5CBjJ5fDrZQLQ1oQ4VerOuo+AR0x3dWtWGt5cnzl64in9u3sV3X+c3fPUvAgIQ3dXxXzhCoRtuKpsLUOg2owo3kEIPF5HNARS6zajCDZQReotwz2OPAI9PJ9kjrWhOhwr9y4ptMLBbE3zxWfYwLyJ70YbYtmIMEsaPo38/ePxCeHrERNvGlbF0zVZs23MIcWJ74fjpC6hZoSjGz/oRCyb0RPo0KXX8vfsPUaxaB2xeOhK//X4keMp9+sJ1OPHXRYzp1yr4vIPGqe+2DUSPNnVw594DDBq3APsPnUbMmO6oW+Vb1K9aQscGBgZi/KxVWLZ2O2LGcMMP9cqhz4g5nHIX7YavklHoclApdDmWFLocSwmhPznaUq5CBjJ5fjrRQLQ1oQ4Veluf8XpE/n3NUsiR5RMkS5Ig1FWHJ/T+Y+Zj9uiuyJczkxatz7BZWv7tmlTReRb9uAXb9xzCtOGdEHIN/Z8bd1CmXnf89uM4eMXyQEDASxSt2h7jBrTBp5nTonbLAciVLT3aNK6Mu/ceoHGn4ejaspaerl+7cTcmzVmDWaO6IG4cL3TqNxk7gkFVjQAAIABJREFU9h6h0O3QXyl0OagUuhxLCl2OpYzQXw/M5GoWfibPTyeEH2RxhEOF/uTpc8xb/is27/wTZ85fRZqPk6FXu7rImyOjxhCe0Nf8uhuLJvkEI9t74AR8R8zGxiUj9M+UmKuV+xrlSxQOJXT1uzqtBqJq2SL6d3sOHEffkXPx6+LhOH32Muq1GYS9P02Cq2s0nWfhqk16RD+oexM06zoShfNl16N2dRw7fQE1mvWl0O3QcSl0OagUuhxLCl2OpYTQHx9rI1chA5liZR9nINqaUIcKPeQlqrXoKfPWYvlP27F1xRi9th6e0PccOIGx/VsHp3n5MhBfV2mH8QPa6JF62fo99Cg8lmfMt4S+eLUavR/G1GEd0XPIDCRJFA9tvq+MrbsPoUOfiUiRNGFwXn//F8iU/mOM698Glb73QatGlVC0cC79+/sPHqFw+VYUuh36K4UuB5VCl2NJocuxlBF6W7kKGcgUK/tYA9HWhFomdHW5as37iwqtsW7eYD1az1+qGVbPGoDk/5dr14FTkTxJwuA19L1/ngy1Dq5yqLVwFxdooZ86cxmj+rzaMPHmY2tB6+u/LByK8g166pH+J6mS49SZS/ihy0jsWDUWLirRG4caoRf7Ig+qlimif3Pu4jWUa9CTQrdDf6XQ5aBS6HIsKXQ5ljJCbydXIQOZYmUfYyDamlCHCn34pCUoUSQf0qVJged+/pi2YB1+2rgH21aMhptbdD31XeabQqhWtgguX7uFqk19Uati8fcK/ejJc2jda5zeLNeucWUU/Tx3mEJXP1TiVrvj1Sh75Yx+Ok6N8mu3GoA8n2ZAi/rlEcPdHRevXIdaHsieOS1Wb9iFJau3YM7Y7ogZw11P8a9Yt4NCt0N/pdDloFLociwpdDmWEkJ/dEz23SK2Xp1X9tG2hloW51Chj52xElt2HcS167fh7hYdWTKmRoem1ZA1Y2oNQI2Wew2dqR9HUxvmVEyKZIneK3RV7rtaXfDgv0d6ul3dGIQ1Qlc/Uxvcug+ajo7NqqFRjVLB0NUud3WzsffPE/Dzf4HUHyVF60aVUDhfNi38cTNX6qn5RAni6Kl3NSvAF8vI91kKXY4phS7HkkKXYyki9OMd5CpkIJNXtlEGoq0JdajQrblE+56Vb4qT40uhy7Gk0OVYUuhyLCWE/vB4R7kKGcjknW2kgWhrQil0k9wpdJMAQxSn0OVYUuhyLCl0OZYyQu8kVyEDmbyzvXqaKjIfFLrJ1qHQTQKk0OUAhshEocthpdDlWMoIvbNchQxk8s423EC0NaEUuknuFLpJgBS6HEAK3S4sKXQ5rBJC/+9EF7kKGcgUO+swA9HWhFLoJrlT6CYBUuhyACl0u7Ck0OWwygi9q1yFDGSKnXWogWhrQil0k9wpdJMAKXQ5gBS6XVhS6HJYJYT+4EQ3uQoZyBQn6xAD0daEUugmuVPoJgFS6HIAKXS7sKTQ5bDKCL27XIUMZIqTdbCBaGtCKXST3Cl0kwApdDmAFLpdWFLoclhFhH6yh1yFDGSKk2WQgWhrQil0k9wpdJMAKXQ5gBS6XVhS6HJYJYR+/2RPuQoZyBQ3y0AD0daEUugmuVPoJgFS6HIAKXS7sKTQ5bDKCL2XXIUMZIqbZYCBaGtCKXST3Cl0kwApdDmAFLpdWFLoclglhP7vyddfoS1Xs/AzxcvSP/wgiyModJMNQKGbBEihywGk0O3CkkKXwyoj9N5yFTKQKV6WV1/oFZkPCt1k61DoJgFS6HIAKXS7sKTQ5bCKCP2Ur1yFDGSKl7mvgWhrQil0s9x7ZTSbgeX/T+BpkXMfBAsXj8SRvp4xPL6I9HVUFXzhdzrS1/NlwL+Rvo6qgo8St4309UyQ3vwXq9w71ceS64yf2ZrzGrlYCt0IrbBiKXSzBIPLU+hiKEGhy7Gk0OVYygjdmpFy/MzWzAwYoU+hG6FFoZul9d7yFLocXgpdjiWFLsdSQuh3T1mzlp0gc+i1+8dPnqH38FnYvucwYnt7olndcqhevmiYsBau2oSVP/+GS1dvIl5cb1QrWwRN65SVA/v/TBS6WaQcoZslyBG6GMHXiSh0OagUuhxLEaGftma3eYJMoXfXK5lf+ecWRvq2xIXL19Gs60hMGdoReT7N8BawMdNXIH+uTMiQ9iOcv3Qd7XzHo2vLWihforAcXAAUulmcFLpZghS6GEEK3Q4oQaHLUZURujXPgyfI9Pr5d/8XAShYprkWeN4cr/ZR+Qybpf/bv0ujcIH5jpgNV1dX9G5fL9xYIwEUuhFaYcVS6GYJUuhiBCl0O6Ck0AWhSgj9zmlr3tiWMNPrN9SpqfNSdbpi38+T4RXLQxNauGoz1m3ei8WT3v+cfGBgICp976On52u8Y4o+osgp9IiSCypHoZslSKGLEaTQ7YCSQheEKiN0a96pnjDT63fInzpzCVWa+OL4ttlwcXHRhNZu3I0Zi9Zj7Zz333Co6fdd+49h0cRecHd3E6TLKXfzMCl08wz/n4Gb4sRQcpe7HEoKXZCliND/suZrTBNmfP21rREdoc9Y9DNWb9iFuWO7I0G82IJkX6XiCN0sUgrdLEGO0MUIcoRuB5QUuiBUEaH/PUywRranSpihS3CwWkMvULo5po/ohNzZX22CU5vkAgPfvYY+Z9kGLFm9FfPG9UDihHFtP7GBSArdAKwwQyl0swQpdDGCFLodUFLoglAlhH7375GCNbI9VYIMoV+KozbBXb91FyN9W+DilRto0mk4Jg/poHe5X795FwtWbkLHZtURLZqLXl+fsWgdZo/uhmRJEuiTRosWDW7RXW2vgA2RFLoNkN4bQqGbJUihixGk0O2AkkIXhCoi9DOjBWtke6oE6duHClbPoSup79h7WG+Ma1G/fPBz6EdOnkOtFv1xZMtMRHd1RfHqHbXkQx5FC+fC+IGyb/eLkkLvMXg60qdJiYY1SobZmuH9PlQhCt32v4hwIrmGLoaSa+hyKCl0QZYiQj87VrBGtqdKkE5Wvraf2fZIpxR6jeb9cOzU+TApVCr1JUoXK4C4cbyQKd3HWLFuB7bsOojJQ17ffVHotncgyUgKXY4mXywjx5LPocuxlBD6vXMT5CpkIFP8T1oZiLYm1CmF7u//Ai/V7gQAnftPRpqPkqFFgwr6366u0fQUSNBBoVvT8cI6K4Uu1xYUuhxLCl2OpYjQz0+Sq5CBTPHTtjAQbU2oUwo9JMp2vScgzcfJ0LZx5eAfB43Avy6cC7Va9sezZ36IHy824njHwsoZ/fDmCF09Xzh9wTrcvvcAWTOmRr/OjZAiacJX+TjlLtZzKXQxlJxyl0PJKXdBlhJC//f8VMEa2Z4qXtofbA+2KDJKC12toYc3QlcvAPAZNlPvXkyXJgXmL9+IDdv2Y8mU3q9eKEChi3VdCl0MJYUuh5JCF2QpIvQL0wVrZHuqeGma2B5sUSSFHs4aeute45ArWzo0qlFKN5F6bd/nFVpj2dQ+r0bpFLpY16XQxVBS6HIoKXRBliJCvzhTsEa2p4qX+nvbgy2KpNDDEXrlxr1x7/5/8PSIGdxEDx890Y8b5MjyCYUu2HEpdDmYXEOXY8k1dDmWEkK/f2mOXIUMZIqbqoGBaGtCo7zQV63/DZt++/Odu9xb9RiLwvmzoWaFYmG3EEfoYj2XQhdDyRG6HEqO0AVZygh9nmCNbE8VN5XsN6PZfmbbI6O80NWX04+evlxvhgva/R5yU9zOfUfRd+QcjOnfGlkzpMajx0+x58BxlCiS/xVlCt323hZOJIUuhpJCl0NJoQuylBD6g8sLBWtke6o4H9e2PdiiyCgvdD8/f6h18qMnzyG2dyz8unj4W7vc12/Zh2kLfsK1G3fg7eWB/LkyY0iPphS6cKel0OWAcspdjiWn3OVYigj9ymK5ChnIFOejmgairQl1eqHbHStH6GKIKXQxlByhy6HkCF2QpYjQry4TrJHtqeKkrGZ7sEWRFLpZ8BS6WYLB5Sl0MZQUuhxKCl2QpYTQ/7u2QrBGtqeKnaKK7cEWRVLoZsFT6GYJUuhiBF8n4pS7HFROucuxlBH6KrkKGcgUO0UlA9HWhFLoZrlT6GYJUuhiBCl0O6DkCF0QqoTQH/6zRrBGtqfyTl7e9mCLIil0s+ApdLMEKXQxghS6HVBS6IJQRYR+/SfBGtmeyjtZWduDLYqk0M2Cp9DNEqTQxQhS6HZASaELQhUR+o31gjWyPZV30ldvC43MB4VutnUodLMEKXQxghS6HVBS6IJQJYT+6MYGwRrZnsor6Xe2B1sUSaGbBU+hmyVIoYsRpNDtgJJCF4QqIvSbmwRrZHsqryTf2B5sUSSFbhY8hW6WIIUuRpBCtwNKCl0QqoTQH9/aIlgj21PFSvyO13/bnsLukRS6WcQUulmCFLoYQQrdDigpdEGoIkK/vU2wRranipXoa9uDLYqk0M2Cp9DNEqTQxQhS6HZASaELQhUR+p3fBGtke6pYCb+0PdiiSArdLHgK3SxBCl2MIIVuB5QUuiBUCaE/ubNLsEa2p/JM+LntwRZFUuhmwVPoZgkGl3/8zd9iueyZKDBBB3umF8kdy++qSB57J7nnmd3epzCd3ztlDdM5HJHA3SudI05j+Tme3N1rSR08ExS05LxGTkqhG6EVViyFbpYghS5G8HUiCl0OKoUux1Ii09N7+yTSGM7hEf8zw2UcXYBCN0ucQjdLkEIXI0ih2wElKHR7UI14zqf//hHxwiZKesTLZ6K0Y4pS6GY5U+hmCVLoYgQpdDugpNDtAdVEzqf3D5ooHfGiHnFzR7ywg0pS6GZBU+hmCVLoYgQpdDugpNDtAdVEzmf3D5soHfGiMePmjHhhB5Wk0M2CptDNEqTQxQhS6HZASaHbA6qJnM8eHDNROuJFY8aJ/Bs4KfSIt++rkhS6WYIUuhhBCt0OKCl0e0A1kfP5fydMlI540Rixs0a8sINKUuhmQVPoZglS6GIEKXQ7oKTQ7QHVRM7nD0+bKB3xojG8M0W8sINKUuhmQVPoZglS6GIEKXQ7oKTQ7QHVRM7nD615X0UM7wwmau2YohS6Wc4UulmCFLoYQQrdDigpdHtANZHT79FZE6UjXvRDeHEPhR7x9n1VkkI3S5BCFyNIodsBJYVuD6gmcvo9vmCidMSLusdKE/HCDipJoZsFTaGbJUihixGk0O2AkkK3B1QTOf2fXDJROuJF3TxTRbywg0pGGaEfOXkOIyYvxemzl+Dq6opPUiVHuyZVkC+nyY0OFLpYV+W73MVQgq9+lWPJN8XJsZTI5P/Umu8pcPNIKVF9u+aIEkJ/7uePr6u0Q8PqJVGzQjEEBLzEkZNn4RXLE7mzpzcHmEI3xy9EaQpdDCWFLoeSI3RBlhKp/J/+I5HGcA43j+SGyzi6QJQQ+vnL11G2Xncc3DgdMdzdwmR8/K8LGDJ+Ec5cuIpkiROgW6taKJAnCy5fu4XqP/TBzFFdkCVDaty6cx8VGvXEmL6tkT9XJq6hC/ZYCl0OJkfociw5QpdjKZHpxbObEmkM54geM4nhMo4uECWErkbo39XqjNzZM6BiyS+QPXNaxPGOFcz67r//aeH7dqyP4l/kxcFjf6Nt7/FYO2cQEsaPg+XrtmPusl+xfFpftOk1DhnSpkTnFv//SkWO0MX6LIUuhpIjdDmUHKELspRI9eL5bYk0hnNEj5HIcBlHF4gSQldQ/7lxBzMXr8eeA8dx7cYdFMqbFb4dGyJZ4viYv2Ijdv9xHFOGvv6e67Y+41GkUE59A6COlj3G4Or123CBC5ZN9YV70EifQhfrsxS6GEoKXQ4lhS7IUiJVgN9diTSGc7i6JzBcxtEFoozQQ4JV0+Y9h8zQP5o+ohOGTlyM1b/sRPx4sYPDnj57jnpVSqBB9e/0z7btOYRWPcaiT6cGqFqmyOt0FLpYn6XQxVBS6HIoKXRBlhKpAvzuS6QxnMPVPa7hMo4uECWFriD/un0/Bo1biB2rxmLu8l9x5MRZjOrTMkz+T54+Q8VGPsifKzN27juKNbMHIk7s/0/ZU+hifZZCF0NJocuhpNAFWUqkCvD/TyKN4Ryubq8HfIYLO6hAlBC6mipfs2EXShYrgBRJE+Lm7XvoM2IOYnnGxPiBbXH7rtro1gu92tZF8S/zIvDlSxw9dV7HJkuSAL2GzoSSuhK+74jZePjoyWv5U+hiXZVCF0NJocuhpNAFWUqkevnisUQawzmiRX+970oVfvzkGXoPn4Xtew4jtrcnmtUth+rlixrOK1kgSgj9/oNHGDZpMfYfPo07d+8jTmwvFMybFZ2b10CC/0+zn/z7IoZPXoLTZy4jmms0ZM+UBj7t6+Ovs5fRb/S84FG5Enul73ujVcOKKPNNQe5yF+yNFLocTO5yl2PJXe5yLCUyvQx4KpHGcI5orh6hyiiZX/nnFkb6tsSFy9fRrOtITBnaEXk+te6d71FC6IZbzkgBjtCN0HpvLIUuhpIjdDmUHKELspRIFfjyuUQawzlcosUILuP/IgAFyzTXAs+bI6P+uc+wWfq//bs0MpxbqgCFbpYkhW6WYHB5Cl0MJYUuh5JCF2QpkSrw5QuJNIZzuESLHlzm0tWbKFWnK/b9PBlesV6N3Beu2ox1m/di8SQfw7mlClDoZklS6GYJUuhiBF8n4pS7HFROucuxlMgUGPhSIo3hHC4u0YLLnDpzCVWa+OL4ttlwcXHRP1+7cTdmLFqPtXMGGs4tVYBCN0uSQjdLkEIXI0ih2wElR+j2gPqB5+QI/QNvwHdWn0IXa1lOuYuh5JS7HEoKXZCls6RSa+gFSjfX7zFRbyBVh9okFxjINfQPu40pdLH2o9DFUFLocigpdEGWzpRKbYK7fusuRvq2wMUrN9Ck03BMHtKBu9w/6Eam0MWaj0IXQ0mhy6Gk0AVZOlMq9Ry6kvqOvYf1xrgW9cvzOfQPvoEpdLEmpNDFUFLocigpdEGWTGVfAtwUZ5YvhW6WYHB5Cl0MJYUuh5JCF2TJVPYlQKGb5UuhmyVIoYsRfJ2Ij63JQeVja3Ismcm+BCh0s3wpdLMEKXQxghS6HVByhG4PqMxpFwIUulmsFLpZghS6GEEK3Q4oKXR7QGVOuxCg0M1ipdDNEqTQxQhS6HZASaHbAypz2oUAhW4XrExKAiRAAiRAAo4lQKE7ljfPRgIkQAIkQAJ2IUCh2wUrk5IACZAACZCAYwlQ6I7lzbORAAmQAAmQgF0IUOh2wRo1kl67cQfJEidAtGivvj6QBwmQAAmQgHUEKHTr2Id75gcPH8PTIybcoruGG2tFQI/B0/HXuSvo3ro28ubIaEUVbD5nZGepLmTFuh34OEUS5M+VyebrcnTgg/8eY86yDWhcqzRiecZ09OltPt9zP3/4+7/Q79jmYY7Ah9AvzV2h85Sm0CNhWz55+hyteozBgaN/IZZHTFQtWwQtG1ZEDHe3SFfbTb8dwIjJS5ElQyp0al4DKZImjFR1/FBYXr95F6XrdkNs71jIkeUTdG5RAymTJYpULFVl+o+eh807/9SzMqq9SxcrEOnq+MvWffAdMRt+fv7ImjENOjarFvwVl5GusgDOXbyGY6cvoHyJwnBxiVyzXR9Kv4yM7WpFnSh0K6iHc87xs1Zh2+5DmDeuB9RIY/S05Th15hKmj+iM+HG9I12NZy5ejzlLf8HLwEBUK/s1mtQuA0+PGJGinh8Kyw59JuHJ02cY17815i7/VY+Ca1Uopm/kIstx5sJVVGnsi3nje8AjZgx0HTAFXxfOhTbfV44sVYT6BqwvK7aBT/t6WpC//X4UfUbORvN65VGt3NeRpp5BFdm66yB6DZ2Jh4+fYPm0vsiU7uNIVcdX/fIpxvVvE9wvq5YpgqZ11N945J2hiVQQHVgZCt2BsG09VdeBUxHd1RUDuzUOLjJ04mL9PbvFv8hjaxqHxN259wCl6nTFgK6NkStbOoyauhxXr9/Sozc1o2D1B9SHwPLPo3+jUfuhWDNnIFJ/lFS32+2797Hv0CmUKV7QIe1oy0m+7zAMiRPGw+AeTXT46bOXUbWpL35fNznSTL9fvnYLJWt3waYlI5D8/7NFV/65hT4j5mDmqC663irm4xSJbblku8UEBgZiyvy1WLByEwZ1a4JWPcdg//qp8IjpbrdzGk0c1C9Xzx6ANB8nC+6XY2esRINq3yFdmhRGUzLezgQodDsDjkj6wyfOomH7oejRpjbU3bA6Xr4MjJSbz9T3AasPzDljugVfqhpp9ho6C4XyZkWVMl9FBIFYmcjOUrWrkuLFKzfwWe7M6NqyFlKlTCJ2/VKJ1DR7W5/xmDioHYoUyqnT7th7BG17j8eetRMi1WitZY8xuHn7X0wb3il4Rivo70fdhDRoNwSbl460bH1d/X10HzQd5y/9g4mD20Pt7+jYZyI2Lhkh1Vym84Tsl4XzZ0OXFjUj5RKQ6Qt1sgQUeiRt0K27D6Fzv8no0qIGqpcvGilrefLvi6jZvD+WTeuDjJ98FFzH85ev6xFQNJdo+iZk74ETyJszk2Wb+97F8ukzP8tHRGrD0ZjpK/To/MdfdmLWkvVoWL2kXrboNmgaEsSNrdvfyhGlWosuW78HsmZMjaMnzyFntvRInyYlFq7ahJJFP0O9qiV020eW/ROqXdv0Goebt+9h/vieiBM7lq6fGhUHvHypR+hpP06m/73y599Q/rvPHdY31c1vq55j8eJFAJZM7g1vL0/d7ht3HMDkIe0jzd+56pejpy/H2jmDdP1mL/1FDy6a1imrl9OU8BU/V9dokabOrAhAoUeSXuD/IgBbd/2JEkXyB9dIiah97wnYsHg4kiWOr3+uPlBv3P5XT28nShDX0trXbT0I6VInh2/HBsH1uP/gkZ6CnzqsI1J9lBSXr91E/TaDsXbuIId94NvCUo2KytXvoT/wrZLlo8dP9fRw6+8ro1rZVzMxagnjwuXryJczE9Rjgbv3H8OsJb+gfdMqofqGIxt++sJ1WP7TdqybNxgBLwOx9tddesNmhrQfoUH1klj58w79+9jenujbqZElPH/7/Yi+0Yjt5anRqB3uddsMQub0qeDbob7+2dqNu7FpxwGMH9hW/1vfQC1ejx9nD9BLXPY+fv/zJDr0mYhiX+TBX+cuwzuWp35CZNX63+ASzQWdm9fQVQgIeKl/nzB+XCRO6Pi/8eB+2ahS8L4D1S9HTV2m/50zazp9I7T7j2MY6dsi0m3ks3c7Rub8FHokaR0lvhrN+mGEb3MUypst+A87T4kmmDCoHfLnzIR2vhNw9sI15P40Aw4e/Vt/mNaqWMySK1A7ifuOmotfFg5FvDivN+qpXdD/PniEUX1a6FFHp36TUPyLvPrfQYe6KXG34/p6eCw/z58dg8YtwPVb9zB+QBtL+KmTBm3YWzG9X6jllH8fPMT+Q6eQKmVSvQdBjepqNO+H7SvHOmwkGQTlv0dPUKxqB72f49uv8r6Xldrg1W/0PC1+Rz8upvqi2pE9pl8rxIzxah168rw1elPc4kk+UE87lK7bFT7t66No4Vx6A2LJ2l31dan+YO9D3WSqTYTqRq1mhWJ6dKtuKFQfUBtflcwrlvwCl67eRLve4/Hfwyd4ERCAWhWL44e6Ze1dvVD5VZ3mLf8V6xcMDXPQoISvbtoTxo8DV1dXqI35Q3r+oGc9eFhLgEK3ln+os6tNKEqApYsXRJGCObFxxx9Yt2kvNi0diWkLfsKiHzdjzeyBerOP+qOq2rQPJgxqi09SJXfoVagPo1J1uqFGhaKo///pVlUBtQu6VosBWDtnIJIlSQD1SNuAMfORO3t6PHz8VG/+iR/PG5Ua+ehpWnuur7+P5Y1bd1G9WV+smjkgeDSpRiCd+k3WMwuOejxQtaE6b9BGOMXw3v2HqNKkt37MSm2MU0sWahd5k07DsXvtRF03JSN10+SoKe7jf11Atoxp3upjag1dffirKdjKpb/SG/jU+rUS1lcFczi0Typh9h42C6fPXtLTwuoZefXomqqL+rfayHXs9HnMGNFZ10uNNg8eO4Pm9cvr5SIlJysOtSv/6yrt9BMsWdKnQuXGvVEo36s164CAAM3zi88+1Td26mbAEYfql+pmaM2G3fp9A7UrfxPqRnLElKU4fvoCpg3rqG/MZyz6WS+rBW06dEQdeY6wCVDokaxnqA90dXe8fc9h/UHZpWVN/SxtobItUb381/ht7xEtwpoVi8Nn2Ex8+VkOlCr2GdSjY998mUe/mMQRhxoFJ0uSMNQfutoFnStberRqVFE/A6zWXdUHZoXvPseBI38hS4bUenpRjUzUIzr2fsNcWCzVdGEbn3GaU6dm1YNRqUeH1FRn0A7uv89fRYa0KR2BMtQ5lq7ZCrXUom4s1HHo+Bl0GTBV10VtSAuS0Ym/L6JZ3XJ6p3HIGRJHVfjhoycoWrU9RvVppZeD1Hr68b8u6nXruWO7613Ralmjz4jZGNrzB/3B74hj576jui6Xrt7SNxVq5Hvj9j1UaNhTr1l/kjqFnvFQfVMtW2VKlwqbdvyBXu3qBW/2c0Q9g86hZmM+L98a+36ejB2/H8HE2T/ip7mDg9eml6/bjr4j52LCwLYOr5+aLRg6cZHesNmvcyP98ij1d1+5sS9WzeyHj5K/elLgp417MGzSYuTIkk7/vmSxz3TfDPlM/a/b9yNvjkxIEC+2I/FGuXNR6B9Ak6tR3FeV2uLw5pnw9/fHlHlroT64bt99gNljuuoNSmoKOXmShGhQ/TtLrmjLzoMYOG4+fp4/VG80U+uuW3b+icWTewf/Yau3jKk1Y7WGqR7Bs+JQo9vPSjfHthVjgkdlJ/66iIbth+Dn+UP0FOOu/cfQfdA0DO/dXDN15Bq7OvfAsfOxaJKPFrUaRTbtPFyv9av14CAZFcidGcmTJtKMlUBDjvIdwVUt/dRrMwg7V48Plo8aESuhTxn66mZE9cn1W/YhY7qPNFc1UrZiWra97wTd1j3b1tUAfdO2AAARm0lEQVT1at1rHLw8PYJv3oJumtSjbupQM03DJi6Blm3+7PoRrbhxvOyCVe26V5vk1K579WiqWstXL8IJOtSNptqxP31EJ/0jJUz1Toq0qZLrv3tHHKpPqs176oVHasZAzQh2+OFVHdVsnZrtUr/r1qo2Hj99hobthqB+tRIo921hHaNuDKo0CX0T4Ih6R8VzUOgfQKurP5qKjXzQvmnV4KlMtVN33aY9aNGggr6C2Ut+0WvC6lE3tcv80LEzKPdtIbi5RXfIFapNMmrdtESRfHj23A9Fq7TXa/9quj3oCLm+rn6mpkkfP35qtw/LsC5cCf2LCm2wdIqvHt2qmYTarQbq9WG1s1ytW1Zs2EuvDRbMmxU79h5Gw+qlUOG7wv9r79yjqirTMP5285I15lRqWY1aNjZpk5ZlXipNzfECJeSl1BDIQEPNBFRMJPCCBqiIomOikVc0uSnUBFipqTU0ldnqoqMrr7N0sttqdRmb9bzMPnMOASGcs89u7+dbqz9ycfbe3+/d57zf916ezzSW6E2GUE+Lq3+vxVEDHuiqOyTDGUFcKGHKGP1/7D4bNWigRWpNL28id9z2R59HPgyukVPT5OKLL9L37B/7P9OeauzcsAs+eOS4/ognRofqznJ76V65tsWVpuSr3e2OxfCoqNmyYVm8VrvvKT8g46amSWlOmuu9Q2rjgaGT5f2SVRqlefDRaA1zD+7bTUp2/l2KS/fJwsQo6dj+l2kHb3y5EEmCTRGZwwIOdQAYUI8LmThXu0jgRLGQh+BQz7s7yqEjJzRVkBAdalpdBThBL2FDZrxLdwDRNoTcc7Nmu54jFhGlG6+XsBEDdB54TxBhwu8Xh28J0KH7lq/Xro4vN3YawwJ6afFM5Zxfcdk+3RXj35ErDBpwn66S/ZEbhJMZNGqqlG5e6Ko6rsivJ2obDPLrqzcWq7AGpG2bNGkss2PDpOMtbb3Gq6YLFb72lqRkbpROHW6Wg0eOyXfffa+FXAgLZ29+VdMC+NGqyFd/L6igzntll+ltRegYCB4br4sPhCrhjGISM7VYySg6e3PvBxKTuEw6dWynrVBfff2tLE6aaEp1NJwf6jz++flJKSrZI/fc2UEXlBhjo5+XDu3beKjIYdGXU1AmP/8s0u/+LlpHYZxT4MsWMqMHHc+LHDXsunF5vOsV2ZBXKrnFOzUkj8Xw4NHTZGdeuiuVgfQX8sZ4R3w1MH+8a5FTU6XJpY01KvTy9jf1uw6m2CU/GZOizr7vvXfqzhg1H3d3usVUBTzc1wilG4WFiTGhcm/XipoJLKAQhdu0fJamXfDcMUmZKjyFKJI/IjS+spkVr0uHbkWrVPNM/zp9VtbkFKss7PQJI3W3g1Xz+twS2ZS/Q77/4QfNGQ7u193v/dXYreG/eXFjtc0F+fXbO9wkUaFD9McTYeW1Gc/qyh0h76gZi2TLyudMywejV/nsV99IRGyKPDXmYf2RNFruliVP1hCiMRD9wIJkzrQKhbTK470DB32mioeIAcKwhjMaFdxPggbeq49w5ouvtNoYEqd4HzDwLqAg8PmZkaa+2bApZGARJSjb/a4kpWVLYfY813uIBdwL67fJjEmj5LprmsuW7W/Ip4c+lxULovVvzGghA68lWVvl8OcnZP6MCE0DID+MhWZSbJj07tFZIzSBIXFaC4KoiFHnge+Zr9pE4SSj4hbrMyCKgPcJNgSvorXzlSkWSEjBHDl2Sm69ubV+j0p3lcsHHx3yaBs10+ibCnZoyseo98C93WtRjGgXev/xbuzat19697CWVLCZvMy4Fx26GZR9cA+Eq+csypZtJXuk331dNNQdnZgpewqX+uBudbskcmeoNn7vw4Me+fU+QyfrLv3CCy+U2PEjtFgOEq29unWS/r3+34dft7ue36eQ1zeER9D6hF0HirjcB36k2v7hGgkdXhFCREHYxvwyjZYgtwi9a1+r4qkzWvWytl0ZTkbrFHaWaygblcmojG7Y8BKJiE3VegB/jcAxcZovNw5uwUIJIe302RNcLZl4NhSvoTr+3Llz2kKGBVP3LhUtm74c2DXGL8jSlAvy57BrxOgA1y2Rp4aaHDoN4Ph9XbyJG0PIBQ4cZyFgB7w8O18dtfF9GDR6mu7Uu3a+1SVAhLQQ3sHHhvTxJa4ar43vi6HpDqEpcCt8cZ5GiBDtgj7BhsyZ+jeIQOC7jxSCFQ8e8htEL96YDt2LMM2+FELbDS65RPNvCCve3jdMHbrVDk1wz68bBX7vFK+Qzw4fk+Ql6zQUh950VBr78+hQtNghj97i6mYephwekaC1CggrYpEyblqaFqhhR3X81BkPVTwz3wEsQLB7m/REsHYRoNIYP/ItrmrmysOa+TzGvY6fPO3SUce/QY9g0crN1S4y0EKGNFFUaJC+C2YcQITvDnbBaAdDfhp2RdW24bxRj/LouOfksSF9tXULw9dV+xAUQoQF35HAB3t4tP7h3cRizRCfwQIOnS2hw/+ii0orDEQRUAmPxRwWcQi9J8940hWOxzMa5z6gtgZRJyrNeddydOje5enXq2H1u+L5aEvnqRBZ6BU0SbXfsUNCuBG99gjBZqXFWk51Cs9314BIyctKksNHT8qUhGXy+ND+KvbhropnVv7f/QV7ZcfbWiT1Unqc/jBiUbd52+vSrk0rDRlbZaAjY37GeimoIgdtVO2jCA0LEWgXIH2AiJOZA1GW1te38Mj5oxcbvfbIrWOgah/1Fze1bqXhd1R6m6UFgIp75NCxAMH7h1y01Y5axUIESn2oRcFic1N+mWDhbhw4g2Nihz6ZIKWb03QhCsljvMOD+3WT8BEDTGttNPO9MvtedOhmE/fh/eAYb2x9re4erTxQYLZybaEkTQ33yFVb8Zmx2wwImS4Tw4MlY3WuhoWhNIbhXrWP3R5ymsYOyoy5YLGBw3EQIkZOFdKnRpGZGfev7T2wExsS/qwKz4SNGOgRwkYLGRw5cusYkEedkbxSXtuUWtvLe+XvjApuqDCCJY6HDXtmfkUl+ZQxWrWPgrq4iSNl4AP36MIj/YUtUrRugWnMoSgHnYJtr+0RHJhipWNrKxsBEQUUaA7qe4/u0CGgEz5lgdbTIM1mDCxUlmcXaC0Ajovmjr1+rzMdev348dN1JLDr7f0ahkVeDT/mXTv/qY5X8u3HkBdE0RRayCDsYhwZWVkVD5XSe8sPSFpCRcuRmQPOBblKnEdvKKGZef/a3AvRjITU1dqKBYeJQr6qqvbxXiQtfFGLwcweeBeXrcmTTQVlWksBrfoXUmK0vQ3h5HZtr/NYsCF8DOlYK0VDzGZW0/2QtgibnCytWl4tnx0+qrUyCxOe0lbL9VtLNDUY2L+7pjpGPjVbi1O73mHN3wErca3pWejQfyuWsulzYmd0RdPLTdvl1AUjKqGv+N1lHv3y7qp4uCZ2JM2aXibjxzzsugXqAm5zq5avy73t9hnkoRFFaNigge543av2MVf0OaP/H7UM/hpIC31x9mtX6x/a1iCo4n7GOvQLIPb0Yvp00wRe/MWjPvfFwmjnvv363YB0LdgOHBmrxX4tm1+pbYzIu+8t/0ieiwnVHXx1tQrlH3yiiwCkHTiqJkCHzjeDBM6TQGVVPHwcSnPDA3vriWgQ1kFlPBS9UCvgq3an83xsS/15VVX7OHN97uK1Hu1u/n5oOKDAkOkaMs7NSnK1Va7JeUX1CnC2AkftCUAZL3RysuzOz9APoe5j+ry/yoGPD+uJjBhVKQxiF4/TEcePeUhTNxx06HwHSMArBNyr9o0L9nwoSp33ZU0u1Z569AyjFxwVyP6Q6/TKRE28iKH9j1oFnE1glQENAtRGDAvoLUVlezVygD5xtBDiQBXsKDlqTwB1ABDueXRIH3m4f09tG0S7bUp8pObaq1MY/PTQUcGCb23GjNrfzIF/yR26A43OKXuXAAp77h8ySXX1n47P0P7rZyKGaYGPv+U6vTtT310NP+xLV+e5NMt9d6faXxmSrMiTr0yJ1tPm0DcPMRUs1iBj6i4+VPur8i+RZlu6Jk8Ffo6fPKOtioY4TVUKg4jmDBw11WUHEqyeAB063w4SqCcB5PZCJ89XtTi0XKHgC8Mqcp31nJ5jPw6lM5xL3+1O34vdOBUy2ttQR4E2vKoUBsFl5oJVGpqH7gMGDquBXgBTWb98a+jQnfpN4ry9RgDtY5A+xQlY7ru2ush1QpIWvdn+OLrVa0B4IRKoA4HKCoO4BOpQHhk7S4IH3qfV8cjBQ9mxy5/by8TwIMuI6tRhuj75CB26T7DyoiQg8mtynWg3y391tzT/39GiUKhLX/Wy5mit2n5Gu5KArwhUVhjEfUZFzZE2N7SU7SV7tGYBGhuNGjbQR0ArpD9OGfTV/L1xXTp0b1DkNUigCgI1yXWu21qiOdnIxwPlhx9/ki2Fr8vipAnyyNh416E1hEoCTiZQVLpXFq3cIgVr5khASJwsTopytQj685RBK9uEDt3K1uGz/aYJVCfXiSM6g8Nnyrqlz7p6apeuzlVZ0a533Coznx79m543H54EvEEgp3CHNL+ymWraz1uyTnPmOGPdSqcMemOe3rwGHbo3afJaJFCJQFVynWkrcjQf6H6q24qXCmTVhiIpXjvfQ8CGQEmABETeeudDgbY+5GHresogVB/btb3e0iJW9bU1HXp9CfLzJHCeBCA6gwM+Qob1108a50YPDeilFb8cJEACngQg8PPElAWSnjRBUlfk1HjKINoNcfzssROnVZEOevLG6W8Zc58WnPRm10GHblfLcl6WJVDw6m7Nn6PIp1GjhqpdXv7+J7I1K0kuvugiyz43H4wE/E3gxx9/ktJd71Z7yuANrVpI8BMzVU72/m6dJLdop/Tp2Vk+PnRUzn75taTOGu/vKfj0/nToPsXLi5NA1QQQNkSr2+VNGuuBJRDW6HFXR+IiARL4FQI1nTIYk5gpP/3nnKTOGqdXgQzzsIgEQQU9ZHqvbXmVrfnSodvavJyc1Qnsfme/bC58w/UDZPXn5fORgFUIVD5lEHr73QPGS/6auXJDq+b6mEhn3T0gUtNbOOXP7oMO3e4W5vxIgARIwAEETpw6IwEh0+XtouWu2Rb+7S1JWb5RtmUny6WNG9qeAh267U3MCZIACZCA/QkgFA/t/ajQID3g58OPD2shHeSYURjnhEGH7gQrc44kQAIk4AACR46eUu33b779Tk7/+0tp1fIqPaHtggsucMDsRejQHWFmTpIESIAEnEUAZylEhQVJx/ZtHDNxOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAwBOnTHmJoTJQESIAESsDMBOnQ7W5dzIwESIAEScAyB/wJxQkwhwoGh9QAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xpl.plot.correlations_plot(width=500, height=450)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Feature distribution\n", + "xpl.plot.distribution_plot(col='Embarked', hue='Title', height=500, nb_cat_max=7, nb_hue_max=5, width=800)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xpl.plot.distribution_plot(col='Age', hue='Title', nb_hue_max=3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing the Confusion Matrix\n", + "\n", + "The confusion matrix is a valuable tool to evaluate the performance of a classification model. It compares the actual labels with the predicted ones, highlighting where the model excels and where it makes errors.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Confusion matrix\n", + "xpl.plot.confusion_matrix_plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using `plot_confusion_matrix`, we can plot the confusion matrix and customize its appearance. For example, you can choose a specific color palette to enhance visualization or align it with your report or presentation style.\n", + "\n", + "#### Customizing the Confusion Matrix Colors\n", + "- **`palette_name`**: Specify the color palette (e.g., \"blues\", \"default\").\n", + "- **`colors_dict`**: Optionally, provide a custom dictionary to define specific colors for elements of the matrix." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Confusion matrix\n", + "plot_confusion_matrix(\n", + " y_true=xpl.y_target.iloc[:, 0].map(encoded_to_original),\n", + " y_pred=xpl.y_pred.iloc[:, 0].map(encoded_to_original),\n", + " palette_name=\"blues\"\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "keltarif_39", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 271c04fcd9f30c48b322cd56e4e599491cd61f30 Mon Sep 17 00:00:00 2001 From: Guillaume VIGNAL Date: Mon, 9 Dec 2024 14:20:51 +0100 Subject: [PATCH 3/5] Transform additionnal plots --- shapash/plots/plot_univariate.py | 8 +++++--- tests/unit_tests/report/test_plots.py | 7 +++---- tests/unit_tests/utils/test_utils.py | 2 +- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/shapash/plots/plot_univariate.py b/shapash/plots/plot_univariate.py index 2c934e92..23d511b3 100644 --- a/shapash/plots/plot_univariate.py +++ b/shapash/plots/plot_univariate.py @@ -165,9 +165,11 @@ def plot_continuous_distribution( else: style_dict = define_style(get_palette(palette_name)) - lower_quantile = df_all[col].quantile(0.005) - upper_quantile = df_all[col].quantile(0.995) - filtered_data = df_all[(df_all[col] > lower_quantile) & (df_all[col] < upper_quantile)].copy() + filtered_data = df_all.copy() + if len(filtered_data) > 200: + lower_quantile = filtered_data[col].quantile(0.005) + upper_quantile = filtered_data[col].quantile(0.995) + filtered_data = filtered_data[(filtered_data[col] > lower_quantile) & (filtered_data[col] < upper_quantile)] # Initialize the figure fig = go.Figure() diff --git a/tests/unit_tests/report/test_plots.py b/tests/unit_tests/report/test_plots.py index a6e78838..f0a913b1 100644 --- a/tests/unit_tests/report/test_plots.py +++ b/tests/unit_tests/report/test_plots.py @@ -4,7 +4,6 @@ import numpy as np import pandas as pd -from shapash.report.common import VarType from shapash.plots.plot_univariate import ( plot_distribution, plot_categorical_distribution, @@ -56,7 +55,7 @@ def test_plot_distribution_3(self, mock_plot_cat, mock_plot_cont): def test_plot_continuous_distribution_1(self): df = pd.DataFrame( { - "int_data": [10, 20, 30, 40], + "int_data": [10, 20, 30, 40, 50], } ) fig = plot_continuous_distribution(df, "int_data") @@ -67,8 +66,8 @@ def test_plot_continuous_distribution_1(self): def test_plot_continuous_distribution_2(self): df = pd.DataFrame( { - "int_data": [10, 20, 30, 40, 50, 30, 20, 0], - "data_train_test": ["train", "train", "train", "train", "test", "test", "test", "test"], + "int_data": [10, 20, 30, 40, 50, 30, 20, 0, 10, 20], + "data_train_test": ["train", "train", "train", "train", "train", "test", "test", "test", "test", "test"], } ) fig = plot_continuous_distribution(df, "int_data", "data_train_test") diff --git a/tests/unit_tests/utils/test_utils.py b/tests/unit_tests/utils/test_utils.py index 91e5959f..3b0d70da 100644 --- a/tests/unit_tests/utils/test_utils.py +++ b/tests/unit_tests/utils/test_utils.py @@ -67,7 +67,7 @@ def test_compute_digit_number_2(self): def test_compute_digit_number_3(self): t = compute_digit_number(0.000044) - assert t == 7 + assert t == 8 def test_truncate_str_1(self): t = truncate_str(12) From 88cad2977a0cf64ebfe9cfcd69d7dd5b7757e42d Mon Sep 17 00:00:00 2001 From: Guillaume VIGNAL Date: Mon, 9 Dec 2024 14:26:58 +0100 Subject: [PATCH 4/5] Rename tuto plot --- ...nb.ipynb => tuto-plot07-additional_plots_visualizations.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tutorial/plots_and_charts/{tuto-plot07-additional_plots_visualizations.ipynb.ipynb => tuto-plot07-additional_plots_visualizations.ipynb} (100%) diff --git a/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb.ipynb b/tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb similarity index 100% rename from tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb.ipynb rename to tutorial/plots_and_charts/tuto-plot07-additional_plots_visualizations.ipynb From 2264563c11f2eb9cd82d0d247f370bbb70399288 Mon Sep 17 00:00:00 2001 From: Guillaume VIGNAL Date: Mon, 9 Dec 2024 14:40:42 +0100 Subject: [PATCH 5/5] fix seaborn dependencie --- shapash/report/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shapash/report/__init__.py b/shapash/report/__init__.py index 6a65f28d..5eee6b5a 100644 --- a/shapash/report/__init__.py +++ b/shapash/report/__init__.py @@ -1,7 +1,7 @@ import importlib # This list should be identical to the list in setup.py -report_requirements = ["nbconvert==6.0.7", "papermill", "matplotlib", "seaborn", "notebook", "Jinja2"] +report_requirements = ["nbconvert==6.0.7", "papermill", "matplotlib", "notebook", "Jinja2"] def check_report_requirements():