Merge pull request #663 from guillaume-vignal/feature/add_error_column_in_datatable_for_webapp

guillaume-vignal · web-flow · commit 8aef41db1d6b · 2025-12-02T12:59:15.000+01:00
Add `_error_` Column Support for Classification
diff --git a/shapash/explainer/smart_explainer.py b/shapash/explainer/smart_explainer.py
@@ -328,7 +328,9 @@ def compile(
             self.predict_proba()
 
         self.y_target = check_y(self.x_init, y_target, y_name="y_target")
-        self.prediction_error = predict_error(self.y_target, self.y_pred, self._case)
+        self.prediction_error = predict_error(
+            self.y_target, self.y_pred, self._case, proba_values=self.proba_values, classes=self._classes
+        )
 
         self._get_contributions_from_backend_or_user(x, contributions)
         self.check_contributions()
@@ -536,14 +538,14 @@ def add(
         """
         if y_pred is not None:
             self.y_pred = check_y(self.x_init, y_pred, y_name="y_pred")
-            if hasattr(self, "y_target"):
-                self.prediction_error = predict_error(self.y_target, self.y_pred, self._case)
         if proba_values is not None:
             self.proba_values = check_y(self.x_init, proba_values, y_name="proba_values")
         if y_target is not None:
             self.y_target = check_y(self.x_init, y_target, y_name="y_target")
-            if hasattr(self, "y_pred"):
-                self.prediction_error = predict_error(self.y_target, self.y_pred, self._case)
+        if hasattr(self, "y_target") and self.y_target is not None:
+            self.prediction_error = predict_error(
+                self.y_target, self.y_pred, self._case, proba_values=self.proba_values, classes=self._classes
+            )
         if label_dict is not None:
             if isinstance(label_dict, dict) is False:
                 raise ValueError(
@@ -1058,7 +1060,9 @@ def predict(self):
         """
         self.y_pred = predict(self.model, self.x_encoded)
         if hasattr(self, "y_target"):
-            self.prediction_error = predict_error(self.y_target, self.y_pred, self._case)
+            self.prediction_error = predict_error(
+                self.y_target, self.y_pred, self._case, proba_values=self.proba_values, classes=self._classes
+            )
 
     def to_pandas(
         self,
diff --git a/shapash/utils/model.py b/shapash/utils/model.py
@@ -11,7 +11,7 @@ def extract_features_model(model, model_attribute):
     """
     Extract features of models if it's possible,
     If not extract the number features of model
-     -------
+    -------
     model: model object
         model used to check the different values of target estimate predict proba
     model_attribute: String or list
@@ -82,30 +82,76 @@ def predict(model, x_encoded):
     return y_pred
 
 
-def predict_error(y_target, y_pred, case):
+def predict_error(y_target, y_pred, model_type, proba_values=None, classes=None):
     """
-    The predict_error function computes the prediction errors from the
-    prediction values and the target values.
+    Compute prediction errors for regression or classification.
+
+    For regression:
+        - If the target can be zero, absolute error is used:
+                error = |y_true - y_pred|
+        - Otherwise, relative error is used:
+                error = |(y_true - y_pred) / y_true|
+
+    For classification:
+        - The error is computed as:
+                error = |1 - P(true_class)|
+        - The probability of the true class is retrieved using the index:
+                col_index = classes.index(label_code)
+            where:
+              * `classes` is the ordered list of label codes coming from the model
+              * `label_code` is the true label from y_target
+              * `proba_values.iloc[:, col_index]` corresponds to P(class == label_code)
 
     Parameters
     ----------
     y_target : pandas.DataFrame
-        1-column dataframe containing the targets.
+        One-column DataFrame containing the ground truth labels.
     y_pred : pandas.DataFrame
-        1-column dataframe containing the predictions.
-    case : str
-        model case
+        One-column DataFrame containing the predicted labels.
+    model_type : str
+        Either "regression" or "classification".
+    proba_values : pandas.DataFrame, optional
+        DataFrame of class probabilities returned by model.predict_proba().
+        Each column corresponds to a class, in the same order as in `classes`.
+    classes : list, optional
+        Ordered list of class label codes (`model.classes_`), used to map the
+        true label to the correct probability column.
 
     Returns
     -------
     pandas.DataFrame
-        1-column dataframe containing the prediction errors.
+        One-column DataFrame containing the prediction errors, named "_error_".
     """
-    prediction_error = None
-    if y_target is not None and y_pred is not None and case == "regression":
+
+    if y_target is None or y_pred is None:
+        return None
+
+    # ================= REGRESSION =================
+    if model_type == "regression":
         if (y_target == 0).any().iloc[0]:
             prediction_error = abs(y_target.values - y_pred.values)
         else:
             prediction_error = abs((y_target.values - y_pred.values) / y_target.values)
-        prediction_error = pd.DataFrame(prediction_error, index=y_target.index, columns=["_error_"])
-    return prediction_error
+
+        return pd.DataFrame(prediction_error, index=y_target.index, columns=["_error_"])
+
+    # ================= CLASSIFICATION =================
+    elif model_type == "classification":
+        if proba_values is None:
+            prediction_error = (y_target.values != y_pred.values).astype(int)
+            return pd.DataFrame(prediction_error, index=y_target.index, columns=["_error_"])
+
+        # classes = order of model.classes_
+        true_labels = y_target.iloc[:, 0]
+        errors = []
+
+        for idx, label_code in true_labels.items():
+            try:
+                col_index = classes.index(label_code)
+            except ValueError as err:
+                raise ValueError(f"Label_code {label_code} not found in classes list: {classes}") from err
+
+            proba_true_class = proba_values.iloc[idx, col_index]
+            errors.append(abs(1 - proba_true_class))
+
+        return pd.DataFrame(errors, index=y_target.index, columns=["_error_"])
diff --git a/shapash/webapp/smart_app.py b/shapash/webapp/smart_app.py
@@ -112,9 +112,7 @@ def __init__(self, explainer, settings: dict = None):
         self.predict_col = ["_predict_"]
         self.special_cols = ["_index_", "_predict_"]
         if self.explainer.y_target is not None:
-            self.special_cols.append("_target_")
-            if self.explainer._case == "regression":
-                self.special_cols.append("_error_")
+            self.special_cols.extend(["_target_", "_error_"])
         self.explainer.features_imp = self.explainer.state.compute_features_import(self.explainer.contributions)
         if self.explainer._case == "classification":
             self.label = self.explainer.check_label_name(len(self.explainer._classes) - 1, "num")[1]
@@ -181,8 +179,7 @@ def init_data(self, rows=None):
             self.dataframe = self.dataframe.join(
                 self.explainer.y_target.rename(columns={self.explainer.y_target.columns[0]: "_target_"}),
             )
-            if self.explainer._case == "regression":
-                self.dataframe = self.dataframe.join(self.explainer.prediction_error)
+            self.dataframe = self.dataframe.join(self.explainer.prediction_error)
 
         if isinstance(self.explainer.columns_order, list):
             special_cols_remaining = [col for col in self.special_cols if col not in self.explainer.columns_order]
diff --git a/tests/unit_tests/utils/test_model.py b/tests/unit_tests/utils/test_model.py
@@ -5,26 +5,74 @@
 from shapash.utils.model import predict_error
 
 y1 = pd.DataFrame(data=np.array([1, 2, 3]), columns=["pred"])
-expected1 = pd.DataFrame(data=np.array([0.0, 0.0, 0.0]), columns=["_error_"])
-
 y2 = pd.DataFrame(data=np.array([0, 2, 3]), columns=["pred"])
+y3 = pd.DataFrame(data=np.array([2, 2, 3]), columns=["pred"])
+
+expected1 = pd.DataFrame(data=np.array([0.0, 0.0, 0.0]), columns=["_error_"])
 expected2 = pd.DataFrame(data=np.array([1, 0, 0]), columns=["_error_"])
+expected3 = pd.DataFrame(data=np.array([0, 0, 0]), columns=["_error_"])
+expected_proba1 = pd.DataFrame({"_error_": [0.9, 0.6, 0.4]})
+expected_proba2 = pd.DataFrame({"_error_": [0.5, 0.4, 0.6]})
+
+proba_values1 = pd.DataFrame(
+        [[0.1, 0.7, 0.2],
+         [0.3, 0.4, 0.3],
+         [0.2, 0.2, 0.6]],
+        columns=[1, 2, 3]
+    )
+
+proba_values2 = pd.DataFrame(
+        [
+            [0.2, 0.5, 0.3],
+            [0.1, 0.6, 0.3],
+            [0.3, 0.3, 0.4],
+        ],
+        columns=[1, 2, 3]
+    )
 
+classes = [1, 2, 3]
 
 @pytest.mark.parametrize(
-    "y_target, y_pred, case, expected",
+    "y_target, y_pred, model_type, proba_values, classes, expected",
     [
-        (None, None, "classification", None),
-        (y1, y1, "classification", None),
-        (y1, None, "regression", None),
-        (None, y1, "regression", None),
-        (y1, y1, "regression", expected1),
-        (y2, y1, "regression", expected2),
+        # -------------------------------
+        # Classification — invalid inputs
+        # -------------------------------
+        (None, None, "classification", None, None, None),
+        (y1, None, "classification", None, None, None),
+        (None, y1, "classification", None, None, None),
+
+        # -------------------------------
+        # Classification — simple 0/1 error
+        # -------------------------------
+        (y1, y1, "classification", None, None, expected3),
+        (y2, y1, "classification", None, None, expected2),
+
+        # -------------------------------
+        # Classification — with proba
+        # error = |1 - P(true_class)|
+        # -------------------------------
+        (y1, y1, "classification", proba_values1, classes, expected_proba1),
+        (y3, y1, "classification", proba_values2, classes, expected_proba2),
+
+        # -------------------------------
+        # Regression — invalid inputs
+        # -------------------------------
+        (y1, None, "regression", None, None, None),
+        (None, y1, "regression", None, None, None),
+
+        # -------------------------------
+        # Regression — working cases
+        # -------------------------------
+        (y1, y1, "regression", None, None, expected1),
+        (y2, y1, "regression", None, None, expected2),
     ],
 )
-def test_predict_error_works(y_target, y_pred, case, expected):
-    result = predict_error(y_target, y_pred, case)
-    if result is not None:
-        assert not pd.testing.assert_frame_equal(result, expected)
+def test_predict_error_works(y_target, y_pred, model_type, proba_values, classes, expected):
+    result = predict_error(y_target, y_pred, model_type, proba_values, classes)
+
+    if expected is None:
+        assert result is None
     else:
-        assert result == expected
+        # DataFrame comparison
+        pd.testing.assert_frame_equal(result, expected)
diff --git a/tests/unit_tests/webapp/utils/test_callbacks.py b/tests/unit_tests/webapp/utils/test_callbacks.py
@@ -77,7 +77,7 @@ def __init__(self, *args, **kwargs):
                 }
             ]
         }
-        self.special_cols = ["_index_", "_predict_", "_target_"]
+        self.special_cols = ["_index_", "_predict_", "_target_", "_error_"]
 
         super().__init__(*args, **kwargs)
 
@@ -87,6 +87,7 @@ def test_default_init_data(self):
                 "_index_": [0, 1, 2, 3, 4],
                 "_predict_": [0, 0, 0, 1, 1],
                 "_target_": [0, 0, 0, 1, 1],
+                "_error_": [0.0, 0.0, 0.0, 0.0, 0.0],
                 "column1": [1, 2, 3, 4, 5],
                 "column3": [1.1, 3.3, 2.2, 4.4, 5.5],
                 "_column2": ["a", "b", "c", "d", "e"],
@@ -318,19 +319,20 @@ def test_get_id_card_features(self):
         selected_row = get_id_card_features(data, 3, self.special_cols, features_dict)
         expected_result = pd.DataFrame(
             {
-                "feature_value": [3, 1, 1, 4, 4.4, "d", False, pd.Timestamp("2023-01-04")],
+                "feature_value": [3, 1, 1, 0, 4, 4.4, "d", False, pd.Timestamp("2023-01-04")],
                 "feature_name": [
                     "_index_",
                     "_predict_",
                     "_target_",
+                    "_error_",
                     "column1",
                     "Useless col",
                     "_Additional col",
                     "_column4",
                     "_column5",
                 ],
             },
-            index=["_index_", "_predict_", "_target_", "column1", "column3", "_column2", "_column4", "_column5"],
+            index=["_index_", "_predict_", "_target_", "_error_", "column1", "column3", "_column2", "_column4", "_column5"],
         )
         pd.testing.assert_frame_equal(selected_row, expected_result)
 
@@ -343,19 +345,20 @@ def test_get_id_card_contrib(self):
     def test_create_id_card_data(self):
         selected_row = pd.DataFrame(
             {
-                "feature_value": [3, 1, 1, 4, 4.4, "d", False, pd.Timestamp("2023-01-04")],
+                "feature_value": [3, 1, 1, 0, 4, 4.4, "d", False, pd.Timestamp("2023-01-04")],
                 "feature_name": [
                     "_index_",
                     "_predict_",
                     "_target_",
+                    "_error_",
                     "column1",
                     "Useless col",
                     "_Additional col",
                     "_column4",
                     "_column5",
                 ],
             },
-            index=["_index_", "_predict_", "_target_", "column1", "column3", "_column2", "_column4", "_column5"],
+            index=["_index_", "_predict_", "_target_", "_error_", "column1", "column3", "_column2", "_column4", "_column5"],
         )
 
         selected_contrib = pd.DataFrame(
@@ -370,34 +373,35 @@ def test_create_id_card_data(self):
         )
         expected_result = pd.DataFrame(
             {
-                "feature_value": [3, 1, 1, 4.4, 4, "d", False, pd.Timestamp("2023-01-04")],
+                "feature_value": [3, 1, 1, 0, 4.4, 4, "d", False, pd.Timestamp("2023-01-04")],
                 "feature_name": [
                     "_index_",
                     "_predict_",
                     "_target_",
+                    "_error_",
                     "Useless col",
                     "column1",
                     "_Additional col",
                     "_column4",
                     "_column5",
                 ],
-                "feature_contrib": [np.nan, np.nan, np.nan, 0.0, -0.6, np.nan, np.nan, np.nan],
+                "feature_contrib": [np.nan, np.nan, np.nan, np.nan, 0.0, -0.6, np.nan, np.nan, np.nan],
             },
-            index=["_index_", "_predict_", "_target_", "column3", "column1", "_column2", "_column4", "_column5"],
+            index=["_index_", "_predict_", "_target_", "_error_", "column3", "column1", "_column2", "_column4", "_column5"],
         )
         pd.testing.assert_frame_equal(selected_data, expected_result)
 
     def test_create_id_card_layout(self):
         selected_data = pd.DataFrame(
             {
-                "feature_value": [3, 1, 1, 4.4, 4, "d"],
-                "feature_name": ["_index_", "_predict_", "_target_", "Useless col", "column1", "_Additional col"],
-                "feature_contrib": [np.nan, np.nan, np.nan, 0.0, -0.6, np.nan],
+                "feature_value": [3, 1, 1, 0, 4.4, 4, "d"],
+                "feature_name": ["_index_", "_predict_", "_target_", "_error_", "Useless col", "column1", "_Additional col"],
+                "feature_contrib": [np.nan, np.nan, np.nan, np.nan, 0.0, -0.6, np.nan],
             },
-            index=["_index_", "_predict_", "_target_", "column3", "column1", "_column2"],
+            index=["_index_", "_predict_", "_target_", "_error_","column3", "column1", "_column2"],
         )
         children = create_id_card_layout(selected_data, self.xpl.additional_features_dict)
-        assert len(children) == 6
+        assert len(children) == 7
 
     def test_get_feature_filter_options(self):
         features_dict = copy.deepcopy(self.xpl.features_dict)
@@ -407,6 +411,7 @@ def test_get_feature_filter_options(self):
             "_index_",
             "_predict_",
             "_target_",
+            "_error_",
             "Useless col",
             "_Additional col",
             "_column4",
