RobustX: Robust Counterfactual Explanations Made Easy

1 Introduction

With the increasing use of Machine Learning (ML) models to aid decision-making in high-stakes fields such as healthcare [Shaheen, 2021] and finance [Cao, 2022], there is a growing need for better explainability of these models. Counterfactual Explanations (CEs) [Guidotti, 2024] are often leveraged in Explainable AI (XAI) to this end due to their intelligibility and alignment with human reasoning [Miller, 2019; Byrne, 2019]. In particular, CEs can offer insights into the predictions produced by an ML model by showing how small changes in its input may lead to different (often more desirable) outcomes. To see what benefits CEs can bring, consider an illustration of a loan application with features 27 years of age, low credit rating, and 15K loan amount. Assume a bank's ML model classifies the application as not creditworthy. A CE for this outcome could be an altered input where a medium credit rating (with the other features unchanged)

would result in the application being classified as creditworthy, thus giving the applicant an idea of what is required to have their loan approved.

Despite their potential, current approaches to generating CEs often fall short in producing robust explanations. Consequently, these methods may produce explanations whose validity is compromised by slight changes in the scenario being explained. For instance, recent work [Upadhyay et al., 2021; Jiang et al., 2023b; Hamman et al., 2023] has highlighted that even small alterations in the parameters of an ML model, e.g. following fine-tuning, may invalidate previously generated CEs. An example of this scenario is captured in Figure 1, where a lack of robustness is demonstrated on a model trained for binary classification tasks. In Figure 1a, an input (yellow circle) receives an initial classification (blue class), and two counterfactuals are generated for it: one (red cross) laying exactly on the decision boundary (full black line) and one deeper inside the counterfactual class (green cross). In Figure 1b, we observe that the decision boundary of the model undergoes slight changes, induced by fine-tuning on a slightly shifted input distribution. As a result, previously generated CEs may cease to be valid if no precautions are taken to ensure robustness. For instance, we observe that the CE corresponding to the red cross is now classified as belonging to the blue class and is thus invalid. Now consider the consequences of these behaviours in our loan example: after finetuning, the applicant changing their credit rating to medium no longer ensures the success of the loan application, as the CE was not robust. When this happens, the CE previously generated by the bank is invalidated, and the bank may be liable for inconsistent statements made to customers regarding loan terms.

This and many other forms of robustness of CEs have recently been the subject of intense research efforts, and numerous algorithms to evaluate the robustness of CEs have been proposed (a recent survey identified about 40 methods [Jiang et al., 2024c]). However, the current state of robust CE research is fragmented, with various methods developed independently and implemented in different, often incompatible, ways. This lack of standardisation has resulted in challenges for the broader research community, as comparing the effectiveness of robust CE generation methods is impractical.

We fill this gap in this paper and introduce RobustX, an open-source Python library to standardise and streamline the generation, evaluation, and benchmarking of robust CEs. RobustX provides flexible, extensible, and customisable tools to implement custom CE methods. Differently from existing frameworks, e.g. [Pawelczyk et al., 2021; Agarwal et al., 2022], our library focuses on providing a consistent framework for testing robustness and systematically comparing various methods, ensuring fair and reliable evaluations. RobustX addresses key limitations on library tools in the current landscape ([Keane et al., 2021; Jiang et al., 2024c]) by offering a standardised approach to robust CE development while also promoting extensibility, allowing users to integrate new datasets and explanation algorithms as needed. The library, including documentation and tutorials, is publicly available at the following link:

https:// github.com/ RobustCounterfactualX/ RobustX

The reminder of this paper is organised as follows. Section 2 presents the main components of the library, providing details about their functionalities. Section 3 demonstrates how easy it is to use RobustX to benchmark existing CE generation algorithms and compare them using different metrics. Finally, Section 4 offers some concluding remarks and pointers for future work.

2 Overview

RobustX implements a complete pipeline for robust CE generation and evaluation (Figure 2) with three major components: Task, CE generator, and CE evaluator. Each has an abstract class template for easy customisation. Users start by creating a task which defines the model and inputs to be explained. Then, the user can choose whether to use RobustX to generate CEs, or directly evaluate the robustness of previously (externally) generated CEs.

Task objects, providing functionality for interactions between models and datasets, are the basic class passed into the CE generation and evaluation pipelines. Our current implementation assumes a ClassificationTask by default, as this is the most commonly considered use case in the literature; however, users can also implement customised Task objects for learning problems other than classification. RobustX natively supports models trained using sklearn [Pedregosa et al., 2011], Keras [Chollet and others, 2015] and PyTorch [Paszke, 2019]. Models trained using other frameworks can also be used by instantiating a BaseModel wrapper class. As far as datasets are concerned, RobustX offers a selection of pre-loaded example datasets that can be readily loaded using the DatasetLoader class. Additionally, this class also allows the uploading of custom datasets if needed via .csv files.

RobustX currently implements nine robust CE generation methods across different robustness use cases reported in the yellow box in Figure 2: AP∆S [Marzari et al., 2024], ArgEnsembling [Jiang et al., 2024b], DiverseRobustCE [Leofante and Potyka, 2024], MCER [Jiang et al., 2023b], ModelMultiplicityMILP [Leofante et al., 2023], PROPLACE [Jiang et al., 2023a], RNCE [Jiang et al., 2024a], ROAR [Upadhyay et al., 2021], STCE [Dutta et al., 2022; Hamman et al., 2023]. It also provides four popular non-robust methods that can be used as baselines to crease new generation methods: BLS [Leofante and Potyka, 2024], MCE [Mohammadi et al., 2021], KDTreeNNCE [Brughmans et al., 2024], and the seminal work by [Wachter et al., 2017]. All methods inherit from the abstract class CEGenerator and implement the generation method() function, providing an easy interface to other components in the pipeline.

CE evaluation methods can take in CEs, either generated within or outside RobustX, and benchmark their robustness along with other common properties identified in the literature. Currently, RobustX provides a CEEvaluator class to evaluate the validity and proximity of CEs [Wachter et al., 2017], as well as five classes specifically focusing on robustness evaluation metrics: VaRRobustnessEvaluator to assess the validity of CEs after retraining [Dutta et al., 2022], DeltaRobustnessEvaluator [Jiang et al., 2023b] to assess the robustness of CEs under plausible model changes, ApproximateDeltaRobustnessEvaluator [Marzari

1 # first prepare a task 2 from robustx.datasets.ExampleDatasets import get_example_dataset 3 from robustx.lib.models.pytorch_models.SimpleNNModel import SimpleNNModel 4 from robustx.lib.tasks.ClassificationTask import ClassificationTask 5 6 data = get_example_dataset("ionosphere") 7 data.default_preprocess() 8 model = SimpleNNModel(34, [8], 1) 9 model.train(data.X, data.y) 10 task = ClassificationTask(model, data) 11 12 # specify the names of the methods and evaluations we want to use, run benchmarking 13 # This will find CEs for all instances predicted with the undesirable class (0) and compare 14 from robustx.lib.DefaultBenchmark import default_benchmark 15 16 methods = ["KDTreeNNCE", "MCE", "MCER", "RNCE", "STCE", "PROPLACE"] 17 evaluations = ["Validity", "Distance", "Delta-robustness"] 18 default_benchmark(task, methods, evaluations, neg_value=0, column_name="target", delta =0.005)

et al., 2024] assessing probabilistic robustness to plausible model changes, SetDistanceRobustnessEvaluator [Leofante and Potyka, 2024] for assessing stability of CEs when the input is perturbed, and MultiplicityValidityRobustnessEvaluator [Leofante et al., 2023] for checking CE robustness under model multiplicity. Additional robustness evaluators can be easily added through the extensible interface provided by RobustX.

3 RobustX in Action

In this section we provide an example on how to use RobustX in practice; additional examples are available online. Figure 3 shows how to run and compare six methods supported by RobustX. In this example we focus on robustness against model changes [Upadhyay et al., 2021] and perform a comparison between four robust methods and two non-robust baselines. To this end, we first import the (pre-loaded) ionosphere dataset for binary classification (line 6) and apply standard pre-processing. We then create and train a simple three-layer neural network model (line 8). A task object is then created from the dataset and model. Then, we specify the CE generation and evaluation methods of interest (line 16 and 17) and run the benchmarking procedure (line 18). The default benchmark function in this example runs each method with its default hyperparameters, although customised hyperparameters can be configured. It then generates CEs for all instances in the dataset which are predicted with an undesirable class (here 102 points with neg value=0), and runs the specified evaluation methods. In this example, we evaluate CEs along three metrics: validity, proximity [Wachter et al., 2017] and ∆-robustness [Jiang et al., 2023b]. The results along the selected evaluation metrics are then printed in a structured table, so that we can easily compare how each method performs.

Table 1 shows the results obtained, and reports the computation time, the percentage of valid CEs, average proximity (L2 distance to the input), and the percentage of CEs that are ∆-robust. Observing this table, users of RobustX will be able to identify that robustness performance improvements from the non-robust baselines (NNCE, MCE) to the robust methods (MCER, RNCE, STCE, PROPLACE) are notable, although MCER fails to achieve 100% robustness. Based on these results, users might conclude that RNCE is the optimal CE generator for this task, balancing between computation time, proximity, and robustness.

4 Conclusion

We presented RobustX, a Python framework to generate, evaluate and compare robust CE for ML models. Our library fills a major gap in the existing literature on robust CEs, providing an easy-to-use and extensible platform to benchmark existing algorithms for robust CEs. Building upon extensive research in the area, RobustX provides a unified platform to run and compare existing approaches, as well as implementing new ones, reducing the need to re-implement software from scratch. Work is underway to further expand the list of available generation algorithms, evaluation methods and additional software facilities for testing and validation to ensure the correctness of the implementations. We believe RobustX will streamline research efforts in robust CEs, accelerating the development of innovative solutions and fostering collaboration within this rapidly growing field.

Contribution Statement

Jiang and Marzari contributed equally.

Acknowledgments

Jiang was funded by J.P. Morgan and by the Royal Academy of Engineering under the Research Chairs and Senior Research Fellowships scheme. Leofante was supported by Imperial College London through the Imperial College Research Fellowship scheme.