acfx 0.1.0__tar.gz

acfx-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Szymon Bobek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

acfx-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: acfx
+Version: 0.1.0
+Summary: Actionable Counterfactual eXplanations
+Author-email: Szymon Bobek <szymon.bobek@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sbobek/acfx
+Project-URL: Documentation, https://acfx.readthedocs.org
+Project-URL: Issues, https://github.com/sbobek/acfx/issues
+Keywords: xai,tabular data,explainability,model-agnostic,counterfactual,causal
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.22.4
+Requires-Dist: pandas>=1.4.3
+Requires-Dist: scipy>=1.11.4
+Requires-Dist: scikit-learn>=1.1.1
+Requires-Dist: optuna>=4.2.0
+Requires-Dist: interpret==0.6.9
+Requires-Dist: interpret-core==0.6.9
+Requires-Dist: overrides>=7.4.0
+Provides-Extra: benchmark
+Requires-Dist: tensorflow==2.14.0; extra == "benchmark"
+Requires-Dist: lingam==1.9.1; extra == "benchmark"
+Requires-Dist: openml==0.15.1; extra == "benchmark"
+Requires-Dist: alibi==0.9.6; extra == "benchmark"
+Requires-Dist: lux-explainer==1.3.2; extra == "benchmark"
+Requires-Dist: networkx==3.4.2; extra == "benchmark"
+Requires-Dist: cfnow==0.0.6; extra == "benchmark"
+Requires-Dist: dice-ml==0.11; extra == "benchmark"
+Requires-Dist: pydotplus==2.0.2; extra == "benchmark"
+Requires-Dist: deap==1.4.2; extra == "benchmark"
+Requires-Dist: pydot==3.0.4; extra == "benchmark"
+Provides-Extra: streamlit-app
+Requires-Dist: streamlit==1.48.0; extra == "streamlit-app"
+Requires-Dist: streamlit-sortables==0.3.1; extra == "streamlit-app"
+Requires-Dist: networkx==3.4.2; extra == "streamlit-app"
+Requires-Dist: lingam==1.9.1; extra == "streamlit-app"
+Dynamic: license-file

acfx-0.1.0/acfx/ACFX.py

@@ -0,0 +1,174 @@
+from typing import Sequence, Tuple, Dict, Optional, List, Self
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.base import ClassifierMixin
+from abc import ABC, abstractmethod
+from .abstract import OptimizerType
+from .evaluation import generate_cfs
+
+
+class ACFX(ABC, BaseEstimator, TransformerMixin):
+    """
+        ACFX: A Counterfactual Explanation Model
+    """
+    def __init__(self, blackbox:ClassifierMixin):
+        """
+
+        Parameters
+        ----------
+        blackbox:
+            Blackbox explainer
+        """
+        self.blackbox = blackbox
+        self.optimizer = None
+        self.optimizer_type = None
+        self.X = None
+        self.categorical_indicator = None
+        self.features_order = None
+        self.pbounds = None
+        self.adjacency_matrix = None
+        self.casual_order = None
+        self.masked_features = None
+
+
+    @abstractmethod
+    def fit(self, X:pd.DataFrame, adjacency_matrix:Optional[np.ndarray], casual_order:Optional[Sequence[int]],
+            pbounds:Dict[str, Tuple[float, float]],y=None, masked_features:Optional[List[str]] = None,
+            categorical_indicator:Optional[List[bool]] =None, features_order:Optional[List[str]] =None) -> Self:
+        """
+        Fits explainer to the sampled data and blackbox model provided in the constructor
+
+        :return:
+        self
+            Fitted estimator.
+
+        Parameters
+        ----------
+        X : {sparse matrix} of shape (n_samples, n_features)
+            Used for counterfactuals generation
+
+        adjacency_matrix:
+            The adjacency matrix representing the causal structure.
+
+        casual_order:
+            The order of variables in the causal graph.
+
+        pbounds:
+            The bounds for each feature to search over (dict with feature names as keys and tuple (min, max) as values).
+
+        y : array-like of shape (n_samples,).
+            Target values used for blackbox model fitting only. You can provide fitted blackbox to constructor or fit it in this method by providing this parameter
+
+        masked_features:
+            List of interchangeable features
+
+        categorical_indicator:
+            True at the index where the variable should be treated as categorical
+
+        features_order:
+            order of features in query instance
+        """
+        if y is not None:
+            self.blackbox.fit(X, y)
+        self.X = X
+        self.categorical_indicator = categorical_indicator
+        self.features_order = features_order
+        self.adjacency_matrix = adjacency_matrix
+        self.casual_order = casual_order
+        self.pbounds = pbounds
+        self.masked_features = masked_features
+        return self
+
+    def predict(self, X):
+        """
+        Predicts using blackbox model
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Used for counterfactuals generation
+
+        Returns
+        -------
+        Prediction class labels for samples in X by blackbox model
+        """
+        return self.blackbox.predict(X)
+
+    def counterfactual(self, query_instance: np.ndarray, desired_class:int, num_counterfactuals: int =1, proximity_weight : float =1,
+                       sparsity_weight : float =1, plausibility_weight : float =0, diversity_weight : float =1, init_points : int =10,
+                       n_iter : int =1000, sampling_from_model : bool=True) -> np.ndarray:
+        """
+        Generates counterfactuals
+
+        Parameters
+        ----------
+        query_instance:
+            The instance to generate counterfactuals for.
+        desired_class:
+            The target class for the counterfactuals.
+        num_counterfactuals:
+            The number of counterfactual instances to generate.
+        proximity_weight:
+            Weight for proximity loss component
+        sparsity_weight:
+            Weight for sparsity loss component
+        plausibility_weight:
+            Weight for plausibility loss component
+        diversity_weight:
+            Weight for diversity loss component
+        init_points:
+            Number of initial points for Bayesian Optimization.
+        n_iter:
+            Number of iterations for Bayesian Optimization.
+        sampling_from_model:
+            true if you want to generate samples from model after sampling from data and generating with relationship graph
+
+        Returns
+        -------
+        np.ndarray:
+            The generated counterfactuals that minimize the loss function.
+        """
+        if plausibility_weight > 0:
+            if self.casual_order is None:
+                raise ValueError("Casual order must be provided if plausibility loss is on")
+            if self.adjacency_matrix is None:
+                raise ValueError("adjacency_matrix must be provided")
+            if self.adjacency_matrix.shape[0] != self.adjacency_matrix.shape[1]:
+                raise ValueError("adjacency matrix must have same number of rows and columns")
+            if self.adjacency_matrix.shape[0] != len(self.casual_order):
+                raise ValueError("adjacency matrix must be of same length as casual order")
+
+        if query_instance is None:
+            raise ValueError("query_instance must not be None")
+        if self.optimizer_type is None:
+            raise ValueError("optimizer_type must be set via fit() before calling counterfactual()")
+        if self.optimizer is None and self.optimizer_type is OptimizerType.Custom:
+            raise ValueError("optimizer must be set before calling counterfactual()")
+        if self.optimizer_type is OptimizerType.LinearAdditive:
+            if not hasattr(self.blackbox, 'coef_'):
+                raise AttributeError('optimizer requires model.coef_ as linear coefficients to be set')
+        return generate_cfs(query_instance=query_instance,
+                            desired_class=desired_class,
+                            adjacency_matrix=self.adjacency_matrix,
+                            casual_order=self.casual_order,
+                            proximity_weight=proximity_weight,
+                            sparsity_weight=sparsity_weight,
+                            plausibility_weight=plausibility_weight,
+                            diversity_weight=diversity_weight,
+                            bounds=self.pbounds,
+                            model=self.blackbox,
+                            features_order=self.features_order,
+                            masked_features= self.masked_features,
+                            categorical_indicator= self.categorical_indicator,
+                            X=self.X,
+                            num_cfs=num_counterfactuals,
+                            init_points=init_points,
+                            n_iter=n_iter,
+                            sampling_from_model=sampling_from_model,
+                            optimizer_type=self.optimizer_type,
+                            optimizer=self.optimizer)
+
+
+

acfx-0.1.0/acfx/AcfxCustom.py

@@ -0,0 +1,81 @@
+import numpy as np
+import pandas as pd
+from overrides import overrides
+from sklearn.base import ClassifierMixin
+from typing import Sequence, Tuple, Dict, Optional, List, Self
+from .ACFX import ACFX
+from .abstract import OptimizerType, ModelBasedCounterOptimizer
+
+
+class AcfxCustom(ACFX):
+    """
+        AcfxCustom: A Counterfactual Explanation Model (using custom blackbox)
+    """
+    def __init__(self, blackbox: ClassifierMixin):
+        """
+
+        Parameters
+        ----------
+        blackbox:
+            Custom blackbox explainer
+        """
+        super().__init__(blackbox)
+
+    @overrides
+    def counterfactual(self, query_instance: np.ndarray, desired_class: int, num_counterfactuals: int = 1, proximity_weight: float = 1,
+                       sparsity_weight: float = 1, plausibility_weight: float = 0, diversity_weight: float = 1,
+                       init_points: int = 10,
+                       n_iter: int = 1000, sampling_from_model: bool = True) -> np.ndarray:
+
+        if self.optimizer is None:
+            raise ValueError("Optimizer must be initialized in fit() before calling counterfactual().")
+        return super().counterfactual(query_instance, desired_class, num_counterfactuals, proximity_weight, sparsity_weight,
+                                                plausibility_weight, diversity_weight, init_points,
+                                      n_iter, sampling_from_model)
+
+    def fit(self, X:pd.DataFrame, adjacency_matrix:Optional[np.ndarray], casual_order:Optional[Sequence[int]],
+            pbounds:Dict[str, Tuple[float, float]],
+            optimizer : ModelBasedCounterOptimizer=None, y=None, masked_features:Optional[List[str]]=None,
+            categorical_indicator:Optional[List[bool]]=None, features_order:Optional[List[str]] =None) -> Self:
+        """
+        Fits explainer to the sampled data and blackbox model provided in the constructor
+
+        :return:
+        self
+            Fitted estimator.
+
+        Parameters
+        ----------
+        X : {sparse matrix} of shape (n_samples, n_features)
+            Used for counterfactuals generation
+
+        adjacency_matrix:
+            The adjacency matrix representing the causal structure.
+
+        casual_order:
+            The order of variables in the causal graph.
+
+        pbounds:
+            The bounds for each feature to search over (dict with feature names as keys and tuple (min, max) as values).
+
+        optimizer:
+            Custom optimizer compliant with blackbox predictor
+
+        y : array-like of shape (n_samples,)
+            Target values used for blackbox model fitting only. You can provide fitted blackbox to constructor or fit it in this method by providing this parameter
+
+        masked_features:
+            List of interchangeable features
+
+        categorical_indicator:
+            True at the index where the variable should be treated as categorical
+
+        features_order:
+            order of features in query instance
+        """
+        self.optimizer_type = OptimizerType.Custom
+        if optimizer is None:
+            raise ValueError("Optimizer must be given for AcfxCustom")
+        self.optimizer = optimizer
+        return super().fit(X, adjacency_matrix, casual_order, pbounds,
+                    y, masked_features,categorical_indicator, features_order)

acfx-0.1.0/acfx/AcfxEBM.py

@@ -0,0 +1,32 @@
+from typing import Sequence, Tuple, Dict, Optional, List, Self
+
+import numpy as np
+import pandas as pd
+from interpret.glassbox import ExplainableBoostingClassifier
+from overrides import overrides
+
+from .ACFX import ACFX
+from .abstract import OptimizerType
+
+class AcfxEBM(ACFX):
+    """
+        AcfxCustom: A Counterfactual Explanation Model (using EBM as blackbox)
+    """
+    def __init__(self, blackbox: ExplainableBoostingClassifier):
+        """
+
+        Parameters
+        ----------
+        blackbox:
+            EBM blackbox explainer
+        """
+        super().__init__(blackbox)
+
+    @overrides
+    def fit(self, X:pd.DataFrame, adjacency_matrix:Optional[np.ndarray], casual_order:Optional[Sequence[int]],
+            pbounds:Dict[str, Tuple[float, float]],y=None, masked_features:Optional[List[str]] = None,
+            categorical_indicator:Optional[List[bool]] =None, features_order:Optional[List[str]] =None) -> Self:
+        self.optimizer_type = OptimizerType.EBM
+        return super().fit(X, adjacency_matrix, casual_order, pbounds,
+                    y, masked_features,categorical_indicator, features_order)
+

acfx-0.1.0/acfx/AcfxLinear.py

@@ -0,0 +1,32 @@
+from typing import Sequence, Tuple, Dict, Optional, List, Self
+
+import numpy as np
+import pandas as pd
+from overrides import overrides
+from sklearn.linear_model._base import LinearClassifierMixin
+
+from .ACFX import ACFX
+from .abstract import OptimizerType
+
+
+class AcfxLinear(ACFX):
+    """
+        AcfxCustom: A Counterfactual Explanation Model (using linear additive model as blackbox)
+    """
+    def __init__(self, blackbox: LinearClassifierMixin):
+        """
+
+        Parameters
+        ----------
+        blackbox:
+            Linear blackbox explainer
+        """
+        super().__init__(blackbox)
+
+    @overrides
+    def fit(self, X:pd.DataFrame, adjacency_matrix:Optional[np.ndarray], casual_order:Optional[Sequence[int]],
+            pbounds:Dict[str, Tuple[float, float]],y=None, masked_features:Optional[List[str]] = None,
+            categorical_indicator:Optional[List[bool]] =None, features_order:Optional[List[str]] =None) -> Self:
+        self.optimizer_type = OptimizerType.LinearAdditive
+        return super().fit(X, adjacency_matrix, casual_order, pbounds,
+                    y, masked_features,categorical_indicator, features_order)

acfx-0.1.0/acfx/__init__.py

@@ -0,0 +1,6 @@
+from .ACFX import ACFX
+from .AcfxEBM import AcfxEBM
+from .AcfxCustom import AcfxCustom
+from .AcfxLinear import AcfxLinear
+
+__all__ = [ACFX, AcfxLinear, AcfxEBM, AcfxCustom]

acfx-0.1.0/acfx/abstract/ModelBasedCounterOptimizer.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict
+
+
+class ModelBasedCounterOptimizer(ABC):
+    @abstractmethod
+    def optimize_proba(self, target_class: int, feature_masked: List[str]) -> Dict[str, float]:
+        """
+        Modifies the instance to increase the probability of the target class by adjusting feature values.
+
+        Parameters:
+        -----------
+        target_class:
+            The desired class to optimize towards.
+        feature_masked:
+            List of interchangeable features
+
+        Returns:
+        -------
+        Dictionary of feature names and their optimized values
+        """
+        pass

acfx-0.1.0/acfx/abstract/OptimizerType.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class OptimizerType(Enum):
+    EBM = 1
+    LinearAdditive = 2
+    Custom = 3

acfx-0.1.0/acfx/abstract/__init__.py

@@ -0,0 +1,3 @@
+from .OptimizerType import OptimizerType
+from .ModelBasedCounterOptimizer import ModelBasedCounterOptimizer
+__all__ = [OptimizerType, ModelBasedCounterOptimizer]

acfx-0.1.0/acfx/evaluation/EBMCounterOptimizer.py

@@ -0,0 +1,199 @@
+from typing import List, Dict
+
+import pandas as pd
+from interpret.glassbox import ExplainableBoostingClassifier
+from overrides import overrides
+from sklearn.utils.extmath import softmax
+import numpy as np
+
+from ..abstract import ModelBasedCounterOptimizer
+
+
+class EBMCounterOptimizer(ModelBasedCounterOptimizer):
+    # Y_TEST = '_eco_y_test'
+    # Y_PRED = '_eco_y_pred'
+    # IS_MODIFIABLE = '_eco_is_modifiable'
+
+    def __init__(self, model: ExplainableBoostingClassifier, X: pd.DataFrame):
+        self.model = model
+        self.X = X
+        self.updated_features = {}
+
+    def _get_optimized_feature_value(self, feature_name, feature_idx, feature_val, features, feature_masked, term_idx,
+                                     class_idx) -> Dict[str, float]:
+        """
+        Returns
+        -------
+        feature value with maximum score for given target class.
+
+        @Todo Needs changes to return optimized value due to given strategy.
+        """
+        # if feature is modifiable and not yet optimized
+        if feature_name in feature_masked and feature_name not in self.updated_features:
+            # if multiclass classification take bins for term and class
+            if len(self.model.term_scores_[term_idx].shape) > 1:
+                class_term_scores = self.model.term_scores_[term_idx].T[class_idx]
+            else:
+                # else take score for class 1 or 1 - score for class 1
+                class_term_scores = self.model.term_scores_[term_idx] if class_idx == 1 else 1 - self.model.term_scores_[
+                    term_idx]
+            # take term that gives best score for target class
+            class_max = np.max(class_term_scores)
+            try:
+                feature_score_idx = np.where(class_term_scores[1:-1] == class_max)[0][0]  ##this is score, not value imho
+            except:
+                print(np.where(class_term_scores[1:-1] == class_max))
+            # we bin differently for main effects and pairs, so first
+            # get the list containing the bins for different resolutions
+            bin_levels = self.model.bins_[feature_idx]
+            # print(f'Feature score index for feature {feature_name} is {feature_score_idx} which represents score equal: {class_max} test: {class_term_scores[feature_score_idx+1]}')
+            # what resolution do we need for this term (main resolution, pair
+            # resolution, etc.), but limit to the last resolution available
+            bins = bin_levels[min(len(bin_levels), len(features)) - 1]
+
+            if len(bins) == 0:
+                feature_val = self.X[feature_name].sample(1).values[0]
+            else:
+                if isinstance(bins, dict):
+                    # categorical feature
+                    # 'unknown' category strings are in the last bin (-1)
+                    feature_val = list(bins.values())[
+                        feature_score_idx - 1]  # if maxscore was 0, or -1 just assign random value
+                else:
+                    # continuous feature
+                    # Get the lower and upper bounds of the specified bin
+                    lower_idx = feature_score_idx - 1
+                    upper_idx = feature_score_idx
+
+                    if lower_idx == -1:
+                        lower = self.model.feature_bounds_[feature_idx][0]
+                    else:
+                        lower = bins[lower_idx]
+
+                    if upper_idx == len(bins):
+                        upper = self.model.feature_bounds_[feature_idx][1]
+                    else:
+                        upper = bins[upper_idx]
+                    # print(f'Drawing randomly from :{lower} to {upper}')
+
+                    # Draw a random number from the range defined by the bin
+                    feature_val = np.random.uniform(lower, upper)
+
+            # print(f'This translates into feature value: {feature_val}')
+
+            self.updated_features.update({feature_name: feature_val})
+        elif feature_name in self.updated_features:
+            feature_val = self.updated_features.get(feature_name)
+        else:
+            self.updated_features.update({feature_name: feature_val})
+
+        return feature_val
+
+    @overrides
+    def optimize_proba(self, target_class : int, feature_masked: List[str]) -> Dict[str, float]:
+        """
+        The method calculates probabilities taking into account the optimization of given parameters towards the target class.
+        Method is based on a default ebm's predict_proba
+
+        Parameters:
+        ebm:
+            Trained EBM model
+        X:
+            Dataset
+        target_class:
+            Target class from which we take the features
+        featured_masked:
+            List of interchangeable features
+        """
+        if target_class not in self.model.classes_:
+            raise KeyError(f'Class "{target_class}" does not exists in given EBM model')
+
+        class_idx = np.where(self.model.classes_ == target_class)[0][0]
+        self.updated_features = {}
+        sample_scores = []
+        cf = {}
+        for index, sample in self.X.iterrows():
+            # start from the intercept for each sample
+            score = self.model.intercept_.copy()
+            if isinstance(score, float) or len(score) == 1:
+                # regression or binary classification
+                score = float(score)
+
+            # we have 2 terms, so add their score contributions
+            for term_idx, features in enumerate(self.model.term_features_):
+                # indexing into a tensor requires a multi-dimensional index
+                tensor_index = []
+                # main effects will have 1 feature, and pairs will have 2 features
+                for feature_idx in features:
+                    feature_name = self.model.feature_names_in_[feature_idx]  # Get the feature name by index
+                    feature_val = sample[feature_name]  # Use the feature name to get the correct value from the sample
+                    bin_idx = 0  # if missing value, use bin index 0
+
+                    if feature_val is not None and feature_val is not np.nan:
+                        # we bin differently for main effects and pairs, so first
+                        # get the list containing the bins for different resolutions
+                        bin_levels = self.model.bins_[feature_idx]
+
+                        # what resolution do we need for this term (main resolution, pair
+                        # resolution, etc.), but limit to the last resolution available
+                        bins = bin_levels[min(len(bin_levels), len(features)) - 1]
+
+                        # here is where the magic is located
+                        feature_val = self._get_optimized_feature_value(feature_name, feature_idx, feature_val,
+                                                                        features, feature_masked, term_idx, class_idx)
+
+                        if isinstance(bins, dict):
+                            # categorical feature
+                            # 'unknown' category strings are in the last bin (-1)
+                            bin_idx = bins.get(feature_val, -1)
+                            if bin_idx == -1:
+                                # check value as string
+                                bin_idx = bins.get(str(feature_val), -1)
+                        else:
+                            # continuous feature
+                            try:
+                                # try converting to a float, if that fails it's 'unknown'
+                                feature_val = float(feature_val)
+                                # add 1 because the 0th bin is reserved for 'missing'
+                                bin_idx = np.digitize(feature_val, bins) + 1
+                            except ValueError:
+                                # non-floats are 'unknown', which is in the last bin (-1)
+                                bin_idx = -1
+
+                        if len(self.model.term_scores_[term_idx].shape) > 1:
+                            sc = self.model.term_scores_[term_idx].T[class_idx][bin_idx]
+                        else:
+                            sc = self.model.term_scores_[term_idx][bin_idx]
+                        # print(f'And feature value {feature_val} translates back to bin index: {bin_idx} which represents score: {sc}')
+
+                        tensor_index.append(bin_idx)
+
+                # local_score is also the local feature importance
+                local_score = self.model.term_scores_[term_idx][tuple(tensor_index)]
+
+                score += local_score
+            sample_scores.append(score)
+
+        predictions = np.array(sample_scores)
+
+        if hasattr(self.model, 'classes_'):
+            # classification
+            if len(self.model.classes_) == 2:
+                # binary classification
+
+                # softmax expects two logits for binary classification
+                # the first logit is always equivalent to 0 for binary classification
+                predictions = [[0, x] for x in predictions]
+            predictions = softmax(predictions)
+
+        #return predictions, self.updated_features
+        return self.updated_features
+
+    # def check_samples(self, target_class, y_test_key, feature_masked):
+    #     X = self.X.copy()
+    #     predictions = self.optimize_proba(target_class, feature_masked)
+    #     X.loc[:, self.Y_TEST] = np.argmax(predictions, axis=1)
+    #     X.loc[:, self.Y_PRED] = X[self.Y_TEST].map({key: val for key, val in enumerate(self.model.classes_)})
+    #     X.loc[:, self.IS_MODIFIABLE] = np.where(X[y_test_key] != X[self.Y_PRED], 1, 0)
+    #
+    #     return X