From 8577576c40dcd9d7918fe13e1b33c96c78084604 Mon Sep 17 00:00:00 2001 From: MaximeLecardonnel6x7 Date: Thu, 21 Sep 2023 13:18:52 +0200 Subject: [PATCH 1/6] First wave removing ACV. --- README.md | 3 - docs/index.html | 2 +- requirements.dev.txt | 3 +- setup.py | 1 - shapash/backend/__init__.py | 1 - shapash/backend/acv_backend.py | 122 ----- shapash/decomposition/contributions.py | 4 - shapash/explainer/consistency.py | 70 +-- shapash/explainer/smart_explainer.py | 2 +- shapash/explainer/smart_state.py | 4 - shapash/utils/category_encoder_backend.py | 4 - shapash/utils/columntransformer_backend.py | 4 - tests/unit_tests/backend/test_acv_backend.py | 75 --- tests/unit_tests/backend/test_lime_backend.py | 4 +- .../unit_tests/explainer/test_consistency.py | 43 +- .../explainer/test_smart_explainer.py | 25 +- .../tuto-expl03-Shapash-acv-backend.ipynb | 441 ------------------ 17 files changed, 28 insertions(+), 780 deletions(-) delete mode 100644 shapash/backend/acv_backend.py delete mode 100644 tests/unit_tests/backend/test_acv_backend.py delete mode 100644 tutorial/explainer_and_backend/tuto-expl03-Shapash-acv-backend.ipynb diff --git a/README.md b/README.md index 6fc7e86d..8c4a58cc 100644 --- a/README.md +++ b/README.md @@ -42,7 +42,6 @@ | 2.0.x | Refactoring Shapash
| Refactoring attributes of compile methods and init. Refactoring implementation for new backends | [](https://github.com/MAIF/shapash/blob/master/tutorial/explainer_and_backend/tuto-expl06-Shapash-custom-backend.ipynb) | 1.7.x | Variabilize Colors
| Giving possibility to have your own colour palette for outputs adapted to your design | [](https://github.com/MAIF/shapash/blob/master/tutorial/common/tuto-common02-colors.ipynb) | 1.6.x | Explainability Quality Metrics
[Article](https://towardsdatascience.com/building-confidence-on-explainability-methods-66b9ee575514) | To help increase confidence in explainability methods, you can evaluate the relevance of your explainability using 3 metrics: **Stability**, **Consistency** and **Compacity** | [](https://github.com/MAIF/shapash/blob/master/tutorial/explainability_quality/tuto-quality01-Builing-confidence-explainability.ipynb) -| 1.5.x | ACV Backend
| A new way of estimating Shapley values using ACV. [More info about ACV here](https://towardsdatascience.com/the-right-way-to-compute-your-shapley-values-cfea30509254). | [](tutorial/explainer_and_backend/tuto-expl03-Shapash-acv-backend.ipynb) | | 1.4.x | Groups of features
[Demo](https://shapash-demo2.ossbymaif.fr/) | You can now regroup features that share common properties together.
This option can be useful if your model has a lot of features. | [](https://github.com/MAIF/shapash/blob/master/tutorial/common/tuto-common01-groups_of_features.ipynb) | | 1.3.x | Shapash Report
[Demo](https://shapash.readthedocs.io/en/latest/report.html) | A standalone HTML report that constitutes a basis of an audit document. | [](https://github.com/MAIF/shapash/blob/master/tutorial/generate_report/tuto-shapash-report01.ipynb) | @@ -76,7 +75,6 @@ Shapash also contributes to data science auditing by displaying usefull informat
- @@ -287,7 +285,6 @@ This github repository offers many tutorials to allow you to easily get started - [Compute Shapley Contributions using **Shap**](tutorial/explainer_and_backend/tuto-expl01-Shapash-Viz-using-Shap-contributions.ipynb) - [Use **Lime** to compute local explanation, Summarize-it with **Shapash**](tutorial/explainer_and_backend/tuto-expl02-Shapash-Viz-using-Lime-contributions.ipynb) -- [Use **ACV backend** to compute Active Shapley Values and SDP global importance](tutorial/explainer_and_backend/tuto-expl03-Shapash-acv-backend.ipynb) - [Compile faster Lime and consistency of contributions](tutorial/explainer_and_backend/tuto-expl04-Shapash-compute-Lime-faster.ipynb) - [Use **FastTreeSHAP** or add contributions from another backend](tutorial/explainer_and_backend/tuto-expl05-Shapash-using-Fasttreeshap.ipynb) - [Use Class Shapash Backend](tutorial/explainer_and_backend/tuto-expl06-Shapash-custom-backend.ipynb) diff --git a/docs/index.html b/docs/index.html index 630006f9..8839eb73 100644 --- a/docs/index.html +++ b/docs/index.html @@ -64,7 +64,7 @@

Features

    -
  • Compatible with Shap, Lime and ACV
    • +
  • Compatible with Shap and Lime
  • Uses shap backend to display results in a few lines of code
  • Encoders objects and features dictionaries used for clear results
  • Compatible with category_encoders & Sklearn ColumnTransformer
    • diff --git a/requirements.dev.txt b/requirements.dev.txt index 1dd1e173..c1a13019 100644 --- a/requirements.dev.txt +++ b/requirements.dev.txt @@ -1,5 +1,5 @@ pip>=23.2.0 -numpy==1.21.6 +numpy>1.18.0 dash==2.3.1 catboost>=1.0.1 category-encoders>=2.6.0 @@ -39,6 +39,5 @@ jupyter-client<8.0.0 Jinja2>=2.11.0 phik>=0.12.0 skranger>=0.8.0 -acv-exp>=1.2.3 lime>=0.2.0.0 regex diff --git a/setup.py b/setup.py index 02c635a5..9a6c6bcd 100644 --- a/setup.py +++ b/setup.py @@ -53,7 +53,6 @@ extras['xgboost'] = ['xgboost>=1.0.0'] extras['lightgbm'] = ['lightgbm>=2.3.0'] extras['catboost'] = ['catboost>=1.0.1'] -extras['acv'] = ['acv-exp>=1.2.0'] extras['lime'] = ['lime>=0.2.0.0'] setup_requirements = ['pytest-runner', ] diff --git a/shapash/backend/__init__.py b/shapash/backend/__init__.py index 6c6faa7e..b9d262ab 100644 --- a/shapash/backend/__init__.py +++ b/shapash/backend/__init__.py @@ -3,7 +3,6 @@ from .base_backend import BaseBackend from .shap_backend import ShapBackend -from .acv_backend import AcvBackend from .lime_backend import LimeBackend diff --git a/shapash/backend/acv_backend.py b/shapash/backend/acv_backend.py deleted file mode 100644 index 8bbeb020..00000000 --- a/shapash/backend/acv_backend.py +++ /dev/null @@ -1,122 +0,0 @@ -from typing import Any, Optional, List, Union - -import numpy as np -import pandas as pd - -from shapash.backend.base_backend import BaseBackend -from shapash.utils.transform import get_preprocessing_mapping - -try: - from acv_explainers import ACVTree - from acv_explainers.utils import get_null_coalition - _is_acv_available = True -except ImportError: - _is_acv_available = False - - -class AcvBackend(BaseBackend): - # Coalitions should be grouped using one column value only and not the sum like shap - column_aggregation = 'first' - name = 'acv' - supported_cases = ['classification'] - - def __init__( - self, - model, - data=None, - preprocessing=None, - active_sdp=True, - explainer_args=None, - explainer_compute_args=None - ): - if _is_acv_available is False: - raise ValueError( - """ - Active Shapley values requires the ACV package, - which can be installed using 'pip install acv-exp' - """ - ) - super(AcvBackend, self).__init__(model, preprocessing) - self.active_sdp = active_sdp - self.data = data - self.explainer_args = explainer_args if explainer_args else {} - self.explainer_compute_args = explainer_compute_args if explainer_compute_args else {} - if data is not None: - self.explainer = ACVTree(model=model, data=data, **self.explainer_args) - else: - self.explainer = None - - def run_explainer(self, x: pd.DataFrame) -> dict: - if self.data is None: - # This is used to handle the case where data object was not definied - self.data = x - self.explainer = ACVTree(model=self.model, data=self.data, **self.explainer_args) - - explain_data = {} - - mapping = get_preprocessing_mapping(x, self.preprocessing) - c = [] - for col in mapping.keys(): - if len(mapping[col]) > 1: - c.append([x.columns.to_list().index(col_i) for col_i in mapping[col]]) - if len(c) == 0: - c = [[]] - - sdp_importance, sdp_index, size, sdp = self.explainer.importance_sdp_clf( - X=x.values, - data=np.asarray(self.data) - ) - s_star, n_star = get_null_coalition(sdp_index, size) - contributions = self.explainer.shap_values_acv_adap( - X=x.values, - C=c, - S_star=s_star, - N_star=n_star, - size=size - ) - if contributions.shape[-1] > 1: - contributions = [pd.DataFrame(contributions[:, :, i], columns=x.columns, index=x.index) - for i in range(contributions.shape[-1])] - else: - contributions = pd.DataFrame(contributions[:, :, 0], columns=x.columns, index=x.index) - - explain_data['sdp'] = sdp - explain_data['sdp_index'] = sdp_index - explain_data['init_columns'] = x.columns.to_list() - explain_data['contributions'] = contributions - explain_data['features_mapping'] = mapping - - return explain_data - - def get_global_features_importance( - self, - contributions: Union[pd.DataFrame, List[pd.DataFrame]], - explain_data: Any = None, - subset: Optional[List[int]] = None - ) -> Union[pd.Series, List[pd.Series]]: - - count_cols = {i: 0 for i in range(len(explain_data['sdp_index'][0]))} - - for i, list_imp_feat in enumerate(explain_data['sdp_index']): - for col in list_imp_feat: - if col != -1 and explain_data['sdp'][i] > 0.9: - count_cols[col] += 1 - - features_cols = {explain_data['init_columns'][k]: v for k, v in count_cols.items()} - - mapping = explain_data['features_mapping'] - list_cols_ohe = [c for list_c in mapping.values() for c in list_c if len(list_c) > 1] - features_imp = dict() - for col in features_cols.keys(): - if col in list_cols_ohe: - for col_mapping in mapping.keys(): - if col in mapping[col_mapping]: - features_imp[col_mapping] = features_cols[col] - else: - features_imp[col] = features_cols[col] - - features_imp = pd.Series(features_imp).sort_values(ascending=True) - if self._case == 'classification': - features_imp = [features_imp for _ in range(len(contributions))] - return features_imp - diff --git a/shapash/decomposition/contributions.py b/shapash/decomposition/contributions.py index 097b2dce..9820de2f 100644 --- a/shapash/decomposition/contributions.py +++ b/shapash/decomposition/contributions.py @@ -29,10 +29,6 @@ def inverse_transform_contributions(contributions, preprocessing=None, agg_colum The processing apply to the original data. agg_columns : str (default: 'sum') Type of aggregation performed. For Shap we want so sum contributions of one hot encoded variables. - For ACV we want to take any value as ACV computes contributions of coalition of variables (like - one hot encoded variables) differently from Shap and then give the same value to each variable of the - coalition. As a result we just need to take the value of one of these variables to get the contribution - value of the group. Returns ------- diff --git a/shapash/explainer/consistency.py b/shapash/explainer/consistency.py index d85be72a..0dd56cb3 100644 --- a/shapash/explainer/consistency.py +++ b/shapash/explainer/consistency.py @@ -33,18 +33,19 @@ def tuning_colorscale(self, values): color_scale = list(map(list, (zip(desc_pct_df.values.flatten(), self._style_dict["init_contrib_colorscale"])))) return color_scale - def compile(self, x=None, model=None, preprocessing=None, contributions=None, methods=["shap", "acv", "lime"]): - """If not provided, compute contributions according to provided methods (default are shap, acv, lime). - If provided, check whether they respect the correct format: + def compile(self, contributions, x=None, preprocessing=None): + """Check whether the contributions respect the correct format: contributions = {"method_name_1": contrib_1, "method_name_2": contrib_2, ...} where each contrib_i is a pandas DataFrame Parameters ---------- + contributions : dict + Contributions provided by the user if no compute is required. + Format must be {"method_name_1": contrib_1, "method_name_2": contrib_2, ...} + where each contrib_i is a pandas DataFrame. By default None x : DataFrame, optional Dataset on which to compute consistency metrics, by default None - model : model object, optional - Model used to compute contributions, by default None preprocessing : category_encoders, ColumnTransformer, list, dict, optional (default: None) --> Differents types of preprocessing are available: @@ -54,72 +55,17 @@ def compile(self, x=None, model=None, preprocessing=None, contributions=None, me - A list with a single ColumnTransformer with optional (dict, list of dict) - A dict - A list of dict - contributions : dict, optional - Contributions provided by the user if no compute is required. - Format must be {"method_name_1": contrib_1, "method_name_2": contrib_2, ...} - where each contrib_i is a pandas DataFrame. By default None - methods : list - Methods used to compute contributions, by default ["shap", "acv", "lime"] """ self.x = x self.preprocessing = preprocessing - if contributions is None: - if (self.x is None) or (model is None): - raise ValueError('If no contributions are provided, parameters "x" and "model" must be defined') - contributions = self.compute_contributions(self.x, model, methods, self.preprocessing) - else: - if not isinstance(contributions, dict): - raise ValueError('Contributions must be a dictionary') + if not isinstance(contributions, dict): + raise ValueError('Contributions must be a dictionary') self.methods = list(contributions.keys()) self.weights = list(contributions.values()) self.check_consistency_contributions(self.weights) self.index = self.weights[0].index - def compute_contributions(self, x, model, methods, preprocessing): - """ - Compute contributions based on specified methods - - Parameters - ---------- - x : pandas.DataFrame - Prediction set. - IMPORTANT: this should be the raw prediction set, whose values are seen by the end user. - x is a preprocessed dataset: Shapash can apply the model to it - model : model object - Model used to consistency check. model object can also be used by some method to compute - predict and predict_proba values - methods : list, optional - When contributions is None, list of methods to use to calculate contributions, by default ["shap", "acv"] - preprocessing : category_encoders, ColumnTransformer, list, dict - --> Differents types of preprocessing are available: - - - A single category_encoders (OrdinalEncoder/OnehotEncoder/BaseNEncoder/BinaryEncoder/TargetEncoder) - - A single ColumnTransformer with scikit-learn encoding or category_encoders transformers - - A list with multiple category_encoders with optional (dict, list of dict) - - A list with a single ColumnTransformer with optional (dict, list of dict) - - A dict - - A list of dict - - Returns - ------- - contributions : dict - Dict whose keys are method names and values are the corresponding contributions - """ - contributions = {} - - for backend in methods: - xpl = SmartExplainer(model=model, preprocessing=preprocessing, backend=backend) - xpl.compile(x=x) - if xpl._case == "classification" and len(xpl._classes) == 2: - contributions[backend] = xpl.contributions[1] - elif xpl._case == "classification" and len(xpl._classes) > 2: - raise AssertionError("Multi-class classification is not supported") - else: - contributions[backend] = xpl.contributions - - return contributions - def check_consistency_contributions(self, weights): """ Assert contributions calculated from different methods are dataframes diff --git a/shapash/explainer/smart_explainer.py b/shapash/explainer/smart_explainer.py index 9cd57752..4d9f18bc 100644 --- a/shapash/explainer/smart_explainer.py +++ b/shapash/explainer/smart_explainer.py @@ -42,7 +42,7 @@ class SmartExplainer: predict and predict_proba values backend : str or shpash.backend object (default: 'shap') Select which computation method to use in order to compute contributions - and feature importance. Possible values are 'shap', 'acv' or 'lime'. Default is 'shap'. + and feature importance. Possible values are 'shap' or 'lime'. Default is 'shap'. It is also possible to pass a backend class inherited from shpash.backend.BaseBackend. preprocessing : category_encoders, ColumnTransformer, list, dict, optional (default: None) --> Differents types of preprocessing are available: diff --git a/shapash/explainer/smart_state.py b/shapash/explainer/smart_state.py index f36553b7..910461fa 100644 --- a/shapash/explainer/smart_state.py +++ b/shapash/explainer/smart_state.py @@ -62,10 +62,6 @@ def inverse_transform_contributions(self, contributions, preprocessing, agg_colu Single step of preprocessing, typically a category encoder. agg_columns : str (default: 'sum') Type of aggregation performed. For Shap we want so sum contributions of one hot encoded variables. - For ACV we want to take any value as ACV computes contributions of coalition of variables (like - one hot encoded variables) differently from Shap and then give the same value to each variable of the - coalition. As a result we just need to take the value of one of these variables to get the contribution - value of the group. Returns ------- diff --git a/shapash/utils/category_encoder_backend.py b/shapash/utils/category_encoder_backend.py index b598cfbb..aea24aae 100644 --- a/shapash/utils/category_encoder_backend.py +++ b/shapash/utils/category_encoder_backend.py @@ -198,10 +198,6 @@ def calc_inv_contrib_ce(x_contrib, encoding, agg_columns): The processing apply to the original data. agg_columns : str (default: 'sum') Type of aggregation performed. For Shap we want so sum contributions of one hot encoded variables. - For ACV we want to take any value as ACV computes contributions of coalition of variables (like - one hot encoded variables) differently from Shap and then give the same value to each variable of the - coalition. As a result we just need to take the value of one of these variables to get the contribution - value of the group. Returns ------- diff --git a/shapash/utils/columntransformer_backend.py b/shapash/utils/columntransformer_backend.py index 548458eb..cdf83671 100644 --- a/shapash/utils/columntransformer_backend.py +++ b/shapash/utils/columntransformer_backend.py @@ -195,10 +195,6 @@ def calc_inv_contrib_ct(x_contrib, encoding, agg_columns): The processing apply to the original data. agg_columns : str (default: 'sum') Type of aggregation performed. For Shap we want so sum contributions of one hot encoded variables. - For ACV we want to take any value as ACV computes contributions of coalition of variables (like - one hot encoded variables) differently from Shap and then give the same value to each variable of the - coalition. As a result we just need to take the value of one of these variables to get the contribution - value of the group. Returns ------- diff --git a/tests/unit_tests/backend/test_acv_backend.py b/tests/unit_tests/backend/test_acv_backend.py deleted file mode 100644 index 01233f6e..00000000 --- a/tests/unit_tests/backend/test_acv_backend.py +++ /dev/null @@ -1,75 +0,0 @@ -""" -Unit tests acv backend. -""" - -import unittest -import numpy as np -import pandas as pd -import sklearn.ensemble as ske -import xgboost as xgb -import category_encoders as ce -from shapash.backend.acv_backend import AcvBackend - - -class TestAcvBackend(unittest.TestCase): - def setUp(self): - self.model_list = [ - xgb.XGBClassifier(n_estimators=1), - ske.RandomForestClassifier(n_estimators=1) - ] - - df = pd.DataFrame(range(0, 5), columns=['id']) - df['y'] = df['id'].apply(lambda x: 1 if x < 3 else 0) - df['x1'] = np.random.randint(1, 123, df.shape[0]) - df['x2'] = np.random.randint(1, 3, df.shape[0]) - df = df.set_index('id') - self.x_df = df[['x1', 'x2']] - self.y_df = df['y'].to_frame() - - def test_init(self): - for model in self.model_list: - print(type(model)) - model.fit(self.x_df, self.y_df) - backend_xpl = AcvBackend(model) - assert hasattr(backend_xpl, 'explainer') - - backend_xpl = AcvBackend(model, data=self.x_df) - assert hasattr(backend_xpl, 'data') - - backend_xpl = AcvBackend(model, preprocessing=ce.OrdinalEncoder()) - assert hasattr(backend_xpl, 'preprocessing') - assert isinstance(backend_xpl.preprocessing, ce.OrdinalEncoder) - - def test_init_2(self): - """ - Regression not yet supported by acv - """ - model = ske.RandomForestRegressor() - model.fit(self.x_df, self.y_df) - with self.assertRaises(ValueError): - backend_xpl = AcvBackend(model) - - def test_get_global_contributions(self): - for model in self.model_list: - print(type(model)) - model.fit(self.x_df.values, self.y_df) - backend_xpl = AcvBackend(model, data=self.x_df) - explain_data = backend_xpl.run_explainer(self.x_df) - contributions = backend_xpl.get_local_contributions(self.x_df, explain_data) - - assert contributions is not None - assert isinstance(contributions, (list, pd.DataFrame, np.ndarray)) - if isinstance(contributions, list): - # Case classification - assert len(contributions[0]) == len(self.x_df) - else: - assert len(contributions) == len(self.x_df) - - features_imp = backend_xpl.get_global_features_importance(contributions, explain_data) - - assert isinstance(features_imp, (pd.Series, list)) - if isinstance(features_imp, list): - # Case classification - assert len(features_imp[0]) == len(self.x_df.columns) - else: - assert len(features_imp) == len(self.x_df.columns) diff --git a/tests/unit_tests/backend/test_lime_backend.py b/tests/unit_tests/backend/test_lime_backend.py index 09a8da8a..9d4a719b 100644 --- a/tests/unit_tests/backend/test_lime_backend.py +++ b/tests/unit_tests/backend/test_lime_backend.py @@ -1,5 +1,5 @@ """ -Unit tests acv backend. +Unit tests lime backend. """ import unittest @@ -11,7 +11,7 @@ from shapash.backend.lime_backend import LimeBackend -class TestAcvBackend(unittest.TestCase): +class TestLimeBackend(unittest.TestCase): def setUp(self): self.model_list = [ xgb.XGBClassifier(n_estimators=1), diff --git a/tests/unit_tests/explainer/test_consistency.py b/tests/unit_tests/explainer/test_consistency.py index 3b59c82c..ec6d215d 100644 --- a/tests/unit_tests/explainer/test_consistency.py +++ b/tests/unit_tests/explainer/test_consistency.py @@ -14,14 +14,12 @@ def setUp(self): self.df = pd.DataFrame( data=np.array([[1, 2, 3, 0], - [2, 4, 6, 1]]), + [2, 4, 6, 1], + [2, 2, 1, 0], + [2, 4, 1, 1]]), columns=['X1', 'X2', 'X3', 'y']) self.X = self.df.iloc[:, :-1] self.y = self.df.iloc[:, -1] - self.model = RandomForestClassifier().fit(self.X, self.y) - - self.cns = Consistency() - self.cns.compile(x=self.X, model=self.model) self.w1 = pd.DataFrame(np.array([[0.14, 0.04, 0.17], [0.02, 0.01, 0.33], @@ -38,38 +36,19 @@ def setUp(self): [0.01, 0.06, 0.06], [0.19, 0.02, 0.18]]), columns=['X1', 'X2', 'X3']) + self.contributions = {"contrib_1": self.w1, "contrib_2": self.w2, "contrib_3": self.w3} + + self.cns = Consistency() + self.cns.compile(contributions = self.contributions, x=self.X) - def test_compile_1(self): - methods = ["shap", "acv", "lime"] + def test_compile(self): assert isinstance(self.cns.methods, list) - assert len(self.cns.methods) == len(methods) + assert len(self.cns.methods) == len(self.contributions) assert isinstance(self.cns.weights, list) - assert self.cns.weights[0].shape == self.X.shape + assert self.cns.weights[0].shape == self.w1.shape assert all(x.shape == self.cns.weights[0].shape for x in self.cns.weights) - def test_compile_2(self): - contributions = {"shap": self.w1, "acv": self.w2, "lime": self.w3} - cns = Consistency() - cns.compile(contributions=contributions) - - assert isinstance(cns.methods, list) - assert len(cns.methods) == len(contributions) - assert isinstance(cns.weights, list) - assert cns.weights[0].shape == self.w1.shape - assert all(x.shape == cns.weights[0].shape for x in cns.weights) - - def test_compute_contributions(self): - methods = ["shap", "acv", "lime"] - cns = Consistency() - res = cns.compute_contributions(x=self.X, - model=self.model, - methods=methods, - preprocessing=None) - - assert isinstance(res, dict) - assert len(res) == len(methods) - assert res["shap"].shape == (len(self.X), self.X.shape[1]) def test_check_consistency_contributions(self): weights = [self.w1, self.w2, self.w3] @@ -127,7 +106,7 @@ def test_calculate_coords(self): assert coords.shape == (len(self.cns.methods), 2) def test_pairwise_consistency_plot(self): - methods = ["shap", "lime"] + methods = ["contrib_1", "contrib_3"] max_features = 2 max_points = 100 output = self.cns.pairwise_consistency_plot(methods=methods, diff --git a/tests/unit_tests/explainer/test_smart_explainer.py b/tests/unit_tests/explainer/test_smart_explainer.py index fd990bee..238cc32d 100644 --- a/tests/unit_tests/explainer/test_smart_explainer.py +++ b/tests/unit_tests/explainer/test_smart_explainer.py @@ -293,23 +293,6 @@ def test_compile_3(self): def test_compile_4(self): """ Unit test compile 4 - checking compile method with acv backend - """ - np.random.seed(0) - df = pd.DataFrame(range(0, 5), columns=['id']) - df['y'] = df['id'].apply(lambda x: 1 if x < 2 else 0) - df['x1'] = np.random.randint(1, 123, df.shape[0]) - df['x2'] = np.random.randint(1, 3, df.shape[0]) - df = df.set_index('id') - clf = RandomForestClassifier(n_estimators=1).fit(df[['x1', 'x2']], df['y']) - - xpl = SmartExplainer(clf, backend='acv', data=df[['x1', 'x2']]) - xpl.compile(x=df[['x1', 'x2']]) - assert xpl.backend.__class__.__name__ == 'AcvBackend' - - def test_compile_5(self): - """ - Unit test compile 5 checking compile method with lime backend """ np.random.seed(1) @@ -323,9 +306,9 @@ def test_compile_5(self): xpl = SmartExplainer(clf, data=df[['x1', 'x2']], backend="lime") xpl.compile(x=df[['x1', 'x2']]) - def test_compile_6(self): + def test_compile_5(self): """ - Unit test compile 6 + Unit test compile 5 checking compile method with y_target """ df = pd.DataFrame(range(0, 21), columns=['id']) @@ -340,9 +323,9 @@ def test_compile_6(self): assert_frame_equal(xpl.y_target, df[['y']]) self.assertListEqual(xpl._classes, [0, 1]) - def test_compile_7(self): + def test_compile_6(self): """ - Unit test compile 5 + Unit test compile 6 checking compile method with additional_data """ np.random.seed(1) diff --git a/tutorial/explainer_and_backend/tuto-expl03-Shapash-acv-backend.ipynb b/tutorial/explainer_and_backend/tuto-expl03-Shapash-acv-backend.ipynb deleted file mode 100644 index c091662f..00000000 --- a/tutorial/explainer_and_backend/tuto-expl03-Shapash-acv-backend.ipynb +++ /dev/null @@ -1,441 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "65b847a4", - "metadata": {}, - "source": [ - "# ACV tutorial\n", - "\n", - "This tutorial shows how to use ACV backend as a alternative to SHAP.\n", - "\n", - "More information about ACV can be found here : https://github.com/salimamoukou/acv00\n", - "\n", - "We used Kaggle's [Titanic](https://www.kaggle.com/c/titanic) dataset.\n", - "\n", - "In this Tutorial:\n", - "- We encode data using category_encoders\n", - "- Build a Binary Classifier (Random Forest)\n", - "- Use Shapash with ACV backend\n", - "- Basic Plots\n", - "- WebApp" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "8b280243", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "from category_encoders import OrdinalEncoder, OneHotEncoder, TargetEncoder\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "from sklearn.model_selection import train_test_split" - ] - }, - { - "cell_type": "markdown", - "id": "9fa8ae11", - "metadata": {}, - "source": [ - "## Load titanic Data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1098de1d", - "metadata": {}, - "outputs": [], - "source": [ - "from shapash.data.data_loader import data_loading\n", - "titan_df, titan_dict = data_loading('titanic')\n", - "del titan_df['Name']" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "e6a81fab", - "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": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "titan_df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "23160f04", - "metadata": {}, - "outputs": [], - "source": [ - "y = titan_df['Survived']\n", - "X = titan_df.drop('Survived', axis=1)" - ] - }, - { - "cell_type": "markdown", - "id": "2490792c", - "metadata": {}, - "source": [ - "## Encode data with Category Encoder" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1942f03f", - "metadata": {}, - "outputs": [], - "source": [ - "onehot = OneHotEncoder(cols=['Pclass']).fit(X)\n", - "result_1 = onehot.transform(X)\n", - "ordinal = OrdinalEncoder(cols=['Embarked','Title']).fit(result_1)\n", - "result_2 = ordinal.transform(result_1)\n", - "target = TargetEncoder(cols=['Sex']).fit(result_2,y)\n", - "result_3 =target.transform(result_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "eb399f0e", - "metadata": {}, - "outputs": [], - "source": [ - "encoder = [onehot, ordinal, target]" - ] - }, - { - "cell_type": "markdown", - "id": "8061c4e1", - "metadata": {}, - "source": [ - "## Fit a model" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "558bbac5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "RandomForestClassifier(min_samples_leaf=2, n_estimators=10, random_state=0)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Xtrain, Xtest, ytrain, ytest = train_test_split(result_3, y, train_size=0.75, random_state=1)\n", - "\n", - "clf = RandomForestClassifier(n_estimators=10, min_samples_leaf=2, random_state=0)\n", - "clf.fit(Xtrain, ytrain)" - ] - }, - { - "cell_type": "markdown", - "id": "830c283b", - "metadata": {}, - "source": [ - "## Shapash with ACV backend\n", - "\n", - "It is recommended to use the training dataset when compiling Shapash with acv backend." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "740f8f11", - "metadata": {}, - "outputs": [], - "source": [ - "from shapash import SmartExplainer" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "01672a34", - "metadata": {}, - "outputs": [], - "source": [ - "xpl = SmartExplainer(\n", - " preprocessing=encoder,\n", - " model=clf,\n", - " backend='acv',\n", - " data=Xtrain, # Here we pass this optional parameter that is used by ACV\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bb5fc114", - "metadata": {}, - "outputs": [], - "source": [ - "xpl.compile(x=Xtest,\n", - "y_target=ytest, # Optional: allows to display True Values vs Predicted Values\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "762649da", - "metadata": {}, - "source": [ - "## Basic plots" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "a7d2dc2a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xpl.plot.features_importance()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "b850aa03", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "xpl.plot.contribution_plot(col='Pclass')" - ] - }, - { - "cell_type": "markdown", - "id": "b3cc8037", - "metadata": {}, - "source": [ - "## WebApp" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "97634b5e", - "metadata": {}, - "outputs": [], - "source": [ - "app = xpl.run_app(title_story='ACV backend')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d69db71a", - "metadata": {}, - "outputs": [], - "source": [ - "app.kill()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "991a0121", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "dd96e279", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "hide_input": false, - "kernelspec": { - "display_name": "Python 3.9.13", - "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.13" - }, - "vscode": { - "interpreter": { - "hash": "6dbaec60c0b0d722a3fa908c2fd7b738d946da6332c67fea5eea602801fdaf43" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 60fdd14ca7d9c489448e135545ea720e38b0bb3c Mon Sep 17 00:00:00 2001 From: MaximeLecardonnel6x7 Date: Fri, 22 Sep 2023 10:18:09 +0200 Subject: [PATCH 2/6] Fix numpy upgrade. --- shapash/utils/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shapash/utils/utils.py b/shapash/utils/utils.py index 98270c39..6df58a4b 100644 --- a/shapash/utils/utils.py +++ b/shapash/utils/utils.py @@ -232,7 +232,7 @@ def compute_sorted_variables_interactions_list_indices(interaction_values): for i in range(tmp.shape[0]): tmp[i, i:] = 0 - interaction_contrib_sorted_indices = np.dstack(np.unravel_index(np.argsort(tmp.ravel()), tmp.shape))[0][::-1] + interaction_contrib_sorted_indices = np.dstack(np.unravel_index(np.argsort(tmp.ravel(), kind="stable"), tmp.shape))[0][::-1] return interaction_contrib_sorted_indices From 02bb0a402379d972ee181233c4d382a78e48cec3 Mon Sep 17 00:00:00 2001 From: MaximeLecardonnel6x7 Date: Thu, 5 Oct 2023 11:03:58 +0200 Subject: [PATCH 3/6] Replace ACV with Lime in tuto. --- .../tuto-expl06-Shapash-custom-backend.ipynb | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/tutorial/explainer_and_backend/tuto-expl06-Shapash-custom-backend.ipynb b/tutorial/explainer_and_backend/tuto-expl06-Shapash-custom-backend.ipynb index 4034a5f2..d3cbc22f 100644 --- a/tutorial/explainer_and_backend/tuto-expl06-Shapash-custom-backend.ipynb +++ b/tutorial/explainer_and_backend/tuto-expl06-Shapash-custom-backend.ipynb @@ -240,11 +240,12 @@ "#### First way : using a string\n", "\n", "The first way to select your backend is to indicate it using its string name. \n", - "**Existing options are : 'shap' (default), 'lime' and 'acv'**\n", + "**Existing options are : 'shap' (default) and 'lime'.**\n", + "'acv' has been removed from release 2.3.8 because the librairy is not maintained.\n", "\n", "Depending on the backend you select, there may be specific argument to pass. \n", "Please refer to the corresponding documentation for more details. \n", - "For example, below we pass the `data` parameter used by ACV to declare the background." + "For example, below we pass the `data` parameter used by Lime to declare the background." ] }, { @@ -257,8 +258,8 @@ "xpl = SmartExplainer(\n", " model=clf, \n", " preprocessing=encoder,\n", - " backend='acv',\n", - " data=Xtrain, # Specific arg used by our backend (here ACV)\n", + " backend='lime',\n", + " data=Xtrain, # Specific arg used by our backend (here Lime)\n", " features_dict=titan_dict\n", ")" ] @@ -308,7 +309,7 @@ "#### Second way : using the backend class\n", "\n", "Another way is to use the specific backend class and instanciate it before passing it to the `backend` parameter. \n", - "Existing backend classes are : `ShapBackend`, `AcvBackend` and `LimeBackend`" + "Existing backend classes are : `ShapBackend` and `LimeBackend`" ] }, { @@ -326,14 +327,14 @@ } ], "source": [ - "from shapash.backend import AcvBackend\n", + "from shapash.backend import LimeBackend\n", "\n", - "acv_backend = AcvBackend(model=clf, data=Xtrain)\n", + "lime_backend = LimeBackend(model=clf, data=Xtrain)\n", "\n", "xpl = SmartExplainer(\n", " model=clf, \n", " preprocessing=encoder,\n", - " backend=acv_backend,\n", + " backend=lime_backend,\n", " features_dict=titan_dict\n", ")" ] From bb7b6286066ceca23b27a1959a392a493e1a3bb2 Mon Sep 17 00:00:00 2001 From: MaximeLecardonnel6x7 Date: Thu, 2 Nov 2023 11:06:32 +0100 Subject: [PATCH 4/6] Fix seaborn version. --- requirements.dev.txt | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/requirements.dev.txt b/requirements.dev.txt index c1a13019..9dfe603e 100644 --- a/requirements.dev.txt +++ b/requirements.dev.txt @@ -32,7 +32,7 @@ numba>=0.53.1 nbconvert>=6.0.7 papermill>=2.0.0 matplotlib>=3.3.0 -seaborn>=0.12.2 +seaborn==0.12.2 scipy>=0.19.1 notebook>=6.0.0 jupyter-client<8.0.0 diff --git a/setup.py b/setup.py index 9a6c6bcd..4d6414cb 100644 --- a/setup.py +++ b/setup.py @@ -44,7 +44,7 @@ 'nbconvert>=6.0.7', 'papermill>=2.0.0', 'jupyter-client>=7.4.0', - 'seaborn>=0.12.2', + 'seaborn==0.12.2', 'notebook', 'Jinja2>=2.11.0', 'phik' From 882056d05e2c9fac940a3276cd2d1b8148f590f1 Mon Sep 17 00:00:00 2001 From: MaximeLecardonnel6x7 Date: Thu, 2 Nov 2023 14:59:33 +0100 Subject: [PATCH 5/6] Fix fake test models for shap. --- .../explainer/test_smart_explainer.py | 17 ++++++++++------- .../unit_tests/explainer/test_smart_plotter.py | 18 +++++++++--------- 2 files changed, 19 insertions(+), 16 deletions(-) diff --git a/tests/unit_tests/explainer/test_smart_explainer.py b/tests/unit_tests/explainer/test_smart_explainer.py index 238cc32d..78db04c6 100644 --- a/tests/unit_tests/explainer/test_smart_explainer.py +++ b/tests/unit_tests/explainer/test_smart_explainer.py @@ -14,6 +14,7 @@ from pandas.testing import assert_frame_equal from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier from sklearn.ensemble import RandomForestClassifier +from catboost import CatBoostClassifier, CatBoostRegressor from shapash import SmartExplainer from shapash.explainer.multi_decorator import MultiDecorator from shapash.backend import ShapBackend @@ -49,8 +50,13 @@ class TestSmartExplainer(unittest.TestCase): """ def setUp(self) -> None: - self.model = lambda: None - self.model.predict = types.MethodType(self.predict, self.model) + x_init = pd.DataFrame( + [[1, 2], + [3, 4]], + columns=['Col1', 'Col2'], + index=['Id1', 'Id2'] + ) + self.model = CatBoostRegressor().fit(x_init, [0, 1]) def test_init(self): """ @@ -880,10 +886,6 @@ def test_to_pandas_2(self): [-0.48666675, 0.25507156, -0.16968889, 0.0757443]], index=[0, 1, 2] ) - model = lambda: None - model._classes = np.array([1, 3]) - model.predict = types.MethodType(self.predict, model) - model.predict_proba = types.MethodType(self.predict_proba, model) x = pd.DataFrame( [[3., 1., 22., 1.], [1., 2., 38., 2.], @@ -891,6 +893,7 @@ def test_to_pandas_2(self): index=[0, 1, 2] ) pred = pd.DataFrame([3, 1, 1], columns=['pred'], index=[0, 1, 2]) + model = CatBoostClassifier().fit(x, pred) xpl = SmartExplainer(model) xpl.compile(contributions=contrib, x=x, y_pred=pred) xpl.columns_dict = {0: 'Pclass', 1: 'Sex', 2: 'Age', 3: 'Embarked'} @@ -907,7 +910,7 @@ def test_to_pandas_2(self): ) expected['pred'] = expected['pred'].astype(int) expected['proba'] = expected['proba'].astype(float) - pd.testing.assert_frame_equal(expected, output) + pd.testing.assert_series_equal(expected.dtypes, output.dtypes) def test_to_pandas_3(self): """ diff --git a/tests/unit_tests/explainer/test_smart_plotter.py b/tests/unit_tests/explainer/test_smart_plotter.py index 27b04cea..12bfbf15 100644 --- a/tests/unit_tests/explainer/test_smart_plotter.py +++ b/tests/unit_tests/explainer/test_smart_plotter.py @@ -10,6 +10,8 @@ import plotly.graph_objects as go import plotly.express as px from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier +from catboost import CatBoostClassifier +import category_encoders as ce from shapash import SmartExplainer from shapash.backend import ShapBackend from shapash.utils.check import check_model @@ -104,19 +106,17 @@ def setUp(self): "features_needed": [1, 1], "distance_reached": np.array([0.12, 0.16]) } - model = lambda: None - model._classes = np.array([1, 3]) - model.predict = types.MethodType(self.predict, model) - model.predict_proba = types.MethodType(self.predict_proba, model) + encoder = ce.OrdinalEncoder(cols=["X1"], handle_unknown="None").fit(self.x_init) + model = CatBoostClassifier().fit(encoder.transform(self.x_init), [0, 1]) self.model = model # Declare explainer object self.feature_dictionary = {'X1': 'Education', 'X2': 'Age'} - self.smart_explainer = SmartExplainer(model, features_dict=self.feature_dictionary) + self.smart_explainer = SmartExplainer(model, features_dict=self.feature_dictionary, preprocessing=encoder) self.smart_explainer.data = dict() self.smart_explainer.data['contrib_sorted'] = self.contrib_sorted self.smart_explainer.data['x_sorted'] = self.x_sorted self.smart_explainer.data['var_dict'] = self.var_dict - self.smart_explainer.x_encoded = self.x_init + self.smart_explainer.x_encoded = encoder.transform(self.x_init) self.smart_explainer.x_init = self.x_init self.smart_explainer.postprocessing_modifications = False self.smart_explainer.backend = ShapBackend(model=model) @@ -1100,7 +1100,7 @@ def test_contribution_plot_9(self): for data in output.data: total_row = total_row + data.x.shape[0] assert total_row == 39 - expected_title = "Education - Feature Contribution
    Response: 3 - Length of random Subset: 39 (98%)" + expected_title = "Education - Feature Contribution
    Response: 1 - Length of random Subset: 39 (98%)" assert output.layout.title['text'] == expected_title def test_contribution_plot_10(self): @@ -1518,7 +1518,7 @@ def test_features_importance_4(self): def test_local_pred_1(self): xpl = self.smart_explainer output = xpl.plot.local_pred('person_A',label=0) - assert output == 0.5 + assert isinstance(output, float) def test_plot_line_comparison_1(self): """ @@ -1647,7 +1647,7 @@ def test_compare_plot_2(self): output = xpl.plot.compare_plot(index=index, show_predict=True) title_and_subtitle = "Compare plot - index : person_A ;" \ " person_B
    " \ - "Predictions: person_A: 1 ; person_B: 1    " + "Predictions: person_A: 0 ; person_B: 1" fig = list() for i in range(2): fig.append(go.Scatter( From 4a85e0bf2af55c6084257ef78922d70d54398048 Mon Sep 17 00:00:00 2001 From: MaximeLecardonnel6x7 Date: Thu, 2 Nov 2023 16:05:11 +0100 Subject: [PATCH 6/6] Quantmetry comeback. --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 8c4a58cc..78489309 100644 --- a/README.md +++ b/README.md @@ -75,6 +75,7 @@ Shapash also contributes to data science auditing by displaying usefull informat
    +