Paper deep dive
FairLint-DL: An IDE-Native Tool for Fairness Debugging of Deep Learning Software
Archit Rathod, Saeid Tizpaz-Niari
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Existing fairness analysis tools predominantly operate as post-training evaluation frameworks, requiring practitioners to complete the full model development lifecycle before assessing bias. We present FairLint-DL, a Visual Studio Code extension that implements a shift-left approach to fairness testing by enabling pre-training, IDE-native bias detection directly on tabular datasets. FairLint-DL trains a configurable deep neural network as a proxy model and applies information-theoretic Quantitative Individual Discrimination (QID) metrics. Grounded in Shannon and min-entropy, QID quantifies the causal influence of protected attributes on predictions. The system implements a two-phase gradient-guided search algorithm for discovering discriminatory instances, a causal debugging pipeline that localizes bias to specific network layers and neurons via sensitivity analysis, and dual explainability engines using SHAP and LIME for feature-level attribution. Evaluation on three tabular benchmarks (Adult Census Income, German Credit, and Bank Marketing) reveals fairness concerns that vary widely across datasets: on Adult, 96.0% of analyzed instances exhibit QID above the 0.1-bit significance threshold, with a mean QID of 0.619 bits and a disparate impact ratio of 0.581, violating the four-fifths legal rule. FairLint-DL produces these results within 12 seconds on cached models, demonstrating the feasibility of integrating fairness analysis into the developer workflow without significant overhead.
Tags
Links
- Source: https://arxiv.org/abs/2609.16321v1
- Canonical: https://arxiv.org/abs/2609.16321v1
Trouble viewing inline? Open PDF directly →
Full Text
36,513 characters extracted from source content.
Expand or collapse full text
FairLint-DL: An IDE-Native Tool for Fairness Debugging of Deep Learning Software DOI: 10.1145/3832783.3834602ISBN: 979-8-4007-2882-2/2026/10Conference: Proceedings of the 41st IEEE/ACM International Conference on Automated Software Engineering; October 12–16, 2026; Munich, GermanyProceedings of the 41st IEEE/ACM International Conference on Automated Software Engineering (ASE ’26), October 12–16, 2026, Munich, Germanyase26tool-p28-pCCS: Software and its engineering Software testing and debuggingCCS: Computing methodologies Machine learning Archit Rathod Affiliation: University of Illinois at Chicago, Chicago, USA email: arath21@uic.edu and Saeid Tizpaz-Niari Affiliation: University of Illinois at Chicago, Chicago, USA email: saeid@uic.edu Received 2026-06-19 Abstract. Existing fairness analysis tools predominantly operate as post-training evaluation frameworks, requiring practitioners to complete the full model development lifecycle before assessing bias. We present FairLint-DL, a Visual Studio Code extension that implements a shift-left approach to fairness testing by enabling pre-training, IDE-native bias detection directly on tabular datasets. FairLint-DL trains a configurable deep neural network as a proxy model and applies information-theoretic Quantitative Individual Discrimination (QID) metrics. Grounded in Shannon and min-entropy, QID quantifies the causal influence of protected attributes on predictions. The system implements a two-phase gradient-guided search algorithm for discovering discriminatory instances, a causal debugging pipeline that localizes bias to specific network layers and neurons via sensitivity analysis, and dual explainability engines using SHAP and LIME for feature-level attribution. Evaluation on three tabular benchmarks (Adult Census Income, German Credit, and Bank Marketing) reveals fairness concerns that vary widely across datasets: on Adult, 96.0% of analyzed instances exhibit QID above the 0.1-bit significance threshold, with a mean QID of 0.619 bits and a disparate impact ratio of 0.581, violating the four-fifths legal rule. FairLint-DL produces these results within 12 seconds on cached models, demonstrating the feasibility of integrating fairness analysis into the developer workflow without significant overhead. Demo video: https://youtu.be/AmfpjK24uwY Source: https://github.com/Archit1706/FairLint-DL Tool: https://open-vsx.org/extension/ArchitRathod/fairlint-dl Keywords: Debugging, Fairness, Deep Learning Software †c-license: by 1. Introduction The widespread adoption of deep neural networks (DNNs) in high-stakes decision-making systems has introduced significant concerns regarding algorithmic fairness. Instances of such AI-assisted software include systems deciding on recidivism risk, software predicting benefit eligibility, and tools deciding whether to audit a given taxpayer (Monjezi et al., 2023). Such models often encode and amplify pre-existing biases in the training data. The resulting fairness defects may disadvantage protected groups and may also violate statutory requirements such as the Civil Rights Act’s disparate impact provisions and the EU AI Act’s fairness mandates. The Shift-Left Fairness Testing Paradigm. Current fairness tools predominantly operate in a post-training paradigm: practitioners must complete the full model development lifecycle. Tools such as IBM’s AI Fairness 360, Google’s What-If Tool, Microsoft’s Fairlearn, and Fairkit-learn (Bellamy et al., 2019; Wexler et al., 2019; Weerts et al., 2023; Johnson and Brun, 2022) provide valuable post-hoc analysis but require significant upfront investment before fairness issues are identified. Pre-training fairness assessment on datasets is itself well studied; our goal is not to claim it as new, but to make it a low-friction step inside the developer’s editor. FairLint-DL applies this shift-left view to fairness testing, analogous to shift-left testing in software engineering. Delivered as a VS Code extension, it lets practitioners assess dataset bias before committing to a specific model architecture or training pipeline. The proxy DNN is trained once and cached as a fairness oracle for the dataset, so iteration cost on the developer’s own model is zero and dataset-level bias signals (QID, group disparities) surface independently of the final architecture. Bias detected early is cheaper to fix; the feedback loop is tighter because results appear where code is written. We use fairness debugging to mean the workflow of detecting, quantifying, localizing, and explaining bias so that a developer can act on it, and we name the tool FairLint-DL because it brings this workflow to the point of editing, in the spirit of a linter, rather than performing static analysis on source code. Contributions. The techniques we build on, namely QID, gradient-guided search, layer and neuron causal localization, and SHAP/LIME attribution, are established in prior work (Monjezi et al., 2023; Dasu et al., 2024; Lundberg and Lee, 2017; Ribeiro et al., 2016); the contribution of this paper is their integration into a single editor-native, pre-training workflow rather than the techniques themselves. Concretely, we contribute: (1) an editor-integrated tool that packages pre-training fairness debugging behind a right-click on a dataset; (2) an end-to-end pipeline combining information-theoretic QID metrics, a two-phase discriminatory-instance search, layer and neuron localization, dual SHAP/LIME attribution, and a composite fairness score; and (3) an evaluation on three tabular fairness benchmarks. 2. Background Fairness Definitions. Individual fairness, formalized by Dwork et al. (Dwork et al., 2012), requires that similar individuals receive similar outcomes. Group fairness requires parity of some statistical measure across demographic groups. FairLint-DL computes Demographic Parity, Equalized Odds (Hardt et al., 2016), and Equal Opportunity. These metrics are complementary: well-known impossibility results show that calibration, equalized odds, and unequal base rates cannot be jointly satisfied (Kleinberg et al., 2016; Chouldechova, 2017), motivating the multi-metric approach. State-of-the-art Tools. The DICE framework (Monjezi et al., 2023) introduced Quantitative Individual Discrimination (QID) as an information-theoretic characterization of discrimination, and a causal debugging algorithm that uses interventions on neuron activations to localize layers and neurons with significant causal effects on QID. NeuFair (Dasu et al., 2024) extends the search via a two-phase global-local approach with gradient-based optimization, and formulates fairness repair as simulated annealing over neuron dropout. FairLint-DL also draws on the EVT framework (Monjezi et al., 2025), which applies extreme value theory to worst-case discrimination. Table 1 compares FairLint-DL with representative tools. AI Fairness 360 and Fairlearn are Python APIs that practitioners instrument after training; the What-If Tool is a post-training GUI; Fairkit-learn targets model selection on the fairness-accuracy frontier; FairLay-ML (Yu et al., 2025) is a separate web application for scikit-learn classifiers; and DICE (Monjezi et al., 2023) and NeuFair (Dasu et al., 2024), the closest research artifacts, are CLI tools tied to benchmark scripts. FairLint-DL combines the information-theoretic rigor of DICE with the search of NeuFair behind an editor-native workflow. Table 1. Positioning of FairLint-DL relative to existing fairness tools. IDE: editor-native integration; Pre: pre-training focus; DNN: DNN causal localization, i.e., attributing bias to specific layers and neurons of a deep network; QID: information-theoretic QID; GS: gradient-guided search; Grp: group fairness; XAI: SHAP/LIME. These dimensions describe the design space FairLint-DL targets, not an exhaustive ranking; toolkits such as AI Fairness 360 and Fairlearn expose many statistical fairness metrics that FairLint-DL does not. Tool IDE Pre DNN QID GS Grp XAI AI Fairness 360 (Bellamy et al., 2019) — — — — — ✓ part. Fairlearn (Weerts et al., 2023) — — — — — ✓ — What-If Tool (Wexler et al., 2019) — — — — — ✓ part. Fairkit-learn (Johnson and Brun, 2022) — — — — — ✓ — FairLay-ML (Yu et al., 2025) — — — — — ✓ LIME DICE (CLI) (Monjezi et al., 2023) — — ✓ ✓ — — — NeuFair (CLI) (Dasu et al., 2024) — — ✓ — ✓ ✓ — FairLint-DL ✓ ✓ ✓ ✓ ✓ ✓ ✓ 3. System Architecture and Design FairLint-DL operates as a client-server application with two primary components communicating over HTTP/REST on localhost:8765 (Figure 1). The VS Code Extension (Client), written in TypeScript, handles all user interaction, file system access, WebView dashboard rendering with Plotly.js charts, and manages the lifecycle of the Python backend. The Python FastAPI Backend (Server) hosts the PyTorch models and all analysis algorithms, including data preprocessing, model training, QID computation, causal debugging, discriminatory instance search, and SHAP/LIME explainability. The extension launches and manages the backend as a local process, so no separate server deployment is required. Because the two components communicate only over HTTP/REST, the tool is not bound to VS Code: the extension runs unmodified in any VS Code-compatible IDE, including Cursor and Antigravity, and the same endpoints can be driven by a CI job or a script. Figure 1. FairLint-DL client-server architecture overview.System architecture diagram showing the VS Code extension on the client side communicating over localhost HTTP REST with a Python FastAPI backend that runs model training, QID analysis, discriminatory instance search, causal debugging, and explainability modules. Six-Step Analysis Pipeline. The pipeline is: model training (or cached load), PCA-based internal space visualization, QID and group fairness computation across all protected attributes (Monjezi et al., 2023), gradient-guided global plus perturbation-based local search for discriminatory instances (Monjezi et al., 2023; Dasu et al., 2024), layer/neuron causal debugging (Monjezi et al., 2023), and batch SHAP (KernelExplainer on log-odds) plus LIME explanations (Lundberg and Lee, 2017; Ribeiro et al., 2016). 4. Algorithmic Methodology DNN Proxy Model. FairLint-DL trains a feedforward DNN as a proxy model to serve as a “fairness oracle.” The default architecture uses 5 fully-connected hidden layers of ⟨64,32,16,8,4⟩ 64,32,16,8,4 neurons followed by a 2-unit softmax output head (∼ 4K parameters total), following the architecture used in prior fairness testing literature (Monjezi et al., 2023; Dasu et al., 2024). Each hidden layer applies Batch Normalization, ReLU activation, and Dropout (p=0.2p=0.2). We train a DNN rather than run statistical tests on raw data because the differentiable model supports counterfactual and gradient-based search, learns non-linear feature interactions, and lets causal debugging trace bias through internal representations. QID Metrics. For non-protected X=xX=x and protected Z=zZ=z, the Shannon entropy QID quantifies prediction uncertainty when varying Z at fixed X: (1) QIDShannon(x)=−∑yP¯(Y=y∣x)log2P¯(Y=y∣x)QID_Shannon(x)=- _y P(Y=y x) _2 P(Y=y x) where P¯(Y=y∣x) P(Y=y x) is the average prediction probability across all counterfactual variations of the protected attributes (Monjezi et al., 2023). FairLint-DL also computes the disparate impact ratio (2) DI(x)=minzP(Y^=1∣x,z)/maxzP(Y^=1∣x,z)DI(x)= _zP( Y=1 x,z)/ _zP( Y=1 x,z) The four-fifths rule (DI≤0.8DI≤ 0.8) is the established U.S. civil rights threshold for adverse impact in employment discrimination; we keep it fixed by legal convention rather than as a tunable knob, whereas the QID significance threshold, epochs, batch size, layer sizes, and sample count are all user-configurable settings. Gradient-Guided Search. The search for discriminatory instances is formulated as a two-phase optimization problem (Monjezi et al., 2023; Dasu et al., 2024). Phase 1 (Global) maximizes the QID score directly using gradient ascent over input features. Phase 2 (Local) explores the neighborhood of the global optimum by adding Gaussian noise to non-protected features and filtering neighbors that exceed a threshold of 0.10.1 bits. Causal Debugging. Layer localization determines which layer is most sensitive to discriminatory inputs by computing the gradient of layer activations with respect to the input and aggregating the magnitude of these gradients for known discriminatory instances. Within the bias-critical layer, neuron localization follows the Average Causal Difference framework from DICE (Monjezi et al., 2023): the tool intervenes on each neuron by forcing it active or inactive and measures the resulting change in QID. Neurons with disproportionately high impact scores are candidates for pruning or repair. Composite Fairness Score. A 0 to 100 score combines five penalty components (mean QID, % discriminatory, disparate impact, max QID, group fairness). The weights are fixed constants in the current release and are listed in the artifact; exposing them as user settings is left to future work. 5. Implementation and Usage Technology Stack. The backend uses PyTorch 2.0+ for model training and gradient computation, FastAPI + Uvicorn for the REST API, Pandas and Scikit-learn for data processing, and SHAP and LIME for feature attribution. The frontend is a TypeScript VS Code extension that renders interactive charts via Plotly.js. Model Caching. To avoid redundant retraining, FairLint-DL caches trained models under a deterministic SHA-256 key computed from the CSV contents, label column, sorted sensitive features, hidden layer sizes, epochs, and batch size. Workflow. Users trigger analysis via the context menu (right-click on a .csv file) (Figure 2). The extension presents QuickPick dialogs for selecting the label column, protected attributes, and model architecture. Protected attributes are auto-detected by matching column names, case-insensitively, against a small curated set of regular expressions for common sensitive categories: sex or gender, race or ethnicity, age, nationality or country, religion, and disability. Auto-detection is only a default; the developer can deselect or add attributes in the QuickPick dialog. Configurable settings are exposed through VS Code’s settings API, including training epochs, batch size, hidden layer configuration, QID threshold, maximum analysis samples, server port, and visualization theme. Availability. FairLint-DL is MIT-licensed and published on the VS Code Marketplace and Open VSX for one-click install in any compatible IDE; from source, npm install && npm run compile builds the extension and pip install -r requirements.txt the backend. The backend ships with a unit-test suite covering QID, search, causal debugging, and group fairness. Figure 2. FairLint-DL integrates into the editor workflow.Screenshot of Visual Studio Code with a CSV file selected in the explorer and a context menu option to launch FairLint-DL analysis, demonstrating how the extension is invoked from the editor. 6. Experimental Evaluation Dataset. The Adult Census Income dataset (Becker and Kohavi, 1996) contains 32,561 records from the 1994 U.S. Census Bureau database; the prediction task is binary classification of whether annual income exceeds $50,000. Four protected attributes were selected: age (71 unique values), race (5), sex (2), and native-country (42). The dataset was split into 22,792 training, 3,256 validation, and 6,513 held-out test instances; the proxy DNN was trained for 30 epochs (training-set class distribution: 17,303 negative, 5,489 positive), and all fairness results below are computed on 500 instances sampled from the held-out test split. To test generalizability beyond a single benchmark, we apply the same architecture and protocol to German Credit (Hofmann, 1994) (1,000 records; protected attributes age and sex) and Bank Marketing (Moro et al., 2014) (45,211 records; protected attributes age and marital status). Table 2 reports QID and composite results for all three; the figures below detail the Adult case. QID Analysis. On Adult, 500 sampled test instances reveal pervasive individual discrimination (Table 2): a mean QID of 0.619 bits (of a 1.0-bit maximum) and a 96.0% discrimination rate mean the model changes its prediction for nearly every individual when protected attributes are altered, and the mean disparate impact of 0.581 falls well below the 0.8 threshold. The QID histogram (Figure 3) is bimodal, with a small cluster near zero and a large mass approaching 1.0 bit, indicating that discrimination is a systemic property of the decision boundary rather than an edge-case phenomenon. The same pipeline surfaces markedly different profiles on the other benchmarks (Table 2): German Credit is the most severe at the individual level (mean QID 0.935, all instances discriminatory), while Bank Marketing is the mildest (mean QID 0.284, 51.6% discriminatory), giving composite scores of 46 and 75 against Adult’s 41. German Credit also illustrates that individual and group views can disagree: nearly every instance is individually discriminatory even though its aggregate disparate impact ratio of 0.94 satisfies the four-fifths rule. Table 2. Individual (QID) and group fairness across three benchmarks (500 test instances each for Adult and Bank; 200 for German). Protected: Adult (age, race, sex, country), German (age, sex), Bank (age, marital). Group diffs are averaged over attributes; Bank’s are near zero as its majority-class predictions give near-equal group rates. Metric Adult German Bank Mean QID (Shannon, bits) 0.619 0.935 0.284 Mean min-entropy QID (bits) 0.214 0.428 0.108 Mean disparate impact ratio 0.581 0.939 0.815 Discriminatory (QID >> 0.1) 96.0% 100.0% 51.6% Violating 80% rule 69.8% 3.5% 42.2% Demographic parity diff. 0.091 0.095 0.000 Equalized odds diff. 0.102 0.114 0.000 Model accuracy (%) 84.1 68.5 88.3 Composite fairness score 41 46 75 Figure 3. Distribution of QID values across 500 analyzed instances on Adult Census; 96.0% exceed the 0.1-bit threshold.Histogram of QID values on the Adult Census dataset, bimodal with a small cluster near zero and a large mass approaching 1.0 bit. Causal Debugging. Layer 2 (32 neurons) is the most bias-sensitive layer (sensitivity 1.933), indicating that early-to-middle layers encode protected information before it propagates deeper. This matches the DICE results on Adult, which also identified the second layer (Monjezi et al., 2023). Within Layer 2, Neurons 30 (1.362), 17 (1.270), and 8 (1.220) have the highest impact and are prime candidates for the neuron-level dropout proposed by NeuFair (Dasu et al., 2024). Figure 4. SHAP and LIME global feature importance on Adult Census; both methods agree that education-num and age (a protected attribute) are top drivers.Bar charts comparing SHAP and LIME global feature importance on Adult Census, both ranking education-num and age among the top drivers. Explainability. SHAP global importance (log-odds) ranks education -num (0.891), age (0.690), and marital-status (0.688) highest; age, a protected attribute, ranks second. SHAP and LIME agree on education-num and on the measurable influence of age (Figure 4), giving high confidence in the attribution. Composite Fairness Score and Performance. Adult’s final score of approximately 41 out of 100 is rated “Concerning.” With caching, the full analysis completes in about 12 (s) (SHAP+LIME dominates at ∼ 7s; other steps ≤ 2s); first-run training adds about 77 (s). 7. Discussion and Limitations Interpretation. On Adult, discrimination is a property of the learned decision boundary rather than an edge case. Although race shows minimal direct SHAP importance (0.010), the group fairness analysis reveals significant discrimination across racial groups (race-specific DP ratio 0.564), suggesting that race influences predictions indirectly through correlated proxy features, a form of proxy discrimination that single-method analysis may miss. Limitations. FairLint-DL trains its own DNN proxy rather than analyzing a user-supplied model, so the detected bias reflects the proxy and may differ from a production model with a different architecture or fairness constraints; we have not yet compared QID on our proxy against alternative families such as gradient-boosted trees. The ≤0≤ 0 vs. >0>0 group split suits binary attributes but not continuous or multi-class ones, where quantile-based splits are a natural extension. SHAP’s KernelExplainer scales quadratically in the number of features and is the bottleneck. Broader validation on intersectional attributes remains future work. 8. Related Work Fairness Testing. Counterfactual discrimination, introduced by Galhotra et al. (Galhotra et al., 2017), catalyzed a broad line of research on generating test cases at scale (Aggarwal et al., 2019; Fan et al., 2022; Biswas and Rajan, 2023). One family of generators operates in a black-box setting and requires no access to the internals of the classifier under test, including AEQUITAS (Udeshi et al., 2018), SG (Aggarwal et al., 2019), ExpGA (Fan et al., 2022), LIMI (Xiao et al., 2023), and AFT (Zhao et al., 2024). A second family adopts a white-box setting and exploits gradient- or neuron-level information from the model, including ADF (Zhang et al., 2020), EIDIG (Zhang et al., 2021), NeuronFair (Zheng et al., 2022), DICE (Monjezi et al., 2023), and MAFT (Wang et al., 2024). FairLint-DL builds on this white-box tradition, and its metrics are closely related to the information-theoretic view of discrimination (Monjezi et al., 2023; Akash et al., 2025). However, FairLint-DL surfaces IDIs early in development and directly within the IDE. The complementary problem of group fairness testing has likewise been studied extensively (Chakraborty et al., 2020; Zhang and Harman, 2021; Chakraborty et al., 2021; Tizpaz-Niari et al., 2022; Robles Herrera et al., 2024). Bias Mitigation. A substantial body of work mitigates bias in machine learning outputs through pre-, in-, and post-processing interventions, including post-processing methods that adjust model decisions after training (Dasu et al., 2024; Sun et al., 2022; Li et al., 2023; Zhang and Sun, 2022; Gao et al., 2022; Dasu et al., 2026). These efforts are largely orthogonal and complementary to FairLint-DL. 9. Conclusion and Future Work We presented FairLint-DL, a VS Code extension for deep learning-based fairness debugging of machine learning datasets. By implementing the shift-left fairness testing paradigm, FairLint-DL enables practitioners to detect, quantify, localize, and explain bias directly within their development environment. Future work includes integrating in-processing fairness interventions such as adversarial debiasing, fairness-constrained optimization (Agarwal et al., 2018), or the NeuFair dropout strategy (Dasu et al., 2024) directly into the extension; extending evaluation to further datasets such as COMPAS; analyzing intersectional fairness across combinations of protected attributes; and supporting external model analysis beyond proxy models. Acknowledgments This project has been partially supported by NSF award CCF-2536640. Data Availability Statement The FairLint-DL source code, datasets, and evaluation scripts are archived on Zenodo (Rathod and Tizpaz-Niari, 2026) (DOI: https://doi.org/10.5281/zenodo.21362910) under the MIT license; the archive includes reproduce.py, which regenerates Table 2 from the bundled datasets. The live source and packaged extension are linked in the abstract. References Agarwal et al. (2018) Alekh Agarwal, Alina Beygelzimer, Miroslav Dudík, John Langford, and Hanna Wallach. 2018. A Reductions Approach to Fair Classification. In Proceedings of the 35th International Conference on Machine Learning (ICML) (PMLR, Vol. 80). 60–69. Aggarwal et al. (2019) Aniya Aggarwal, Pranay Lohia, Seema Nagar, Kuntal Dey, and Diptikalyan Saha. 2019. Black Box Fairness Testing of Machine Learning Models. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2019). 625–635. doi:10.1145/3338906.3338937 Akash et al. (2025) Ranit D. Akash, Ashish Kumar, Verya Monjezi, Ashutosh Trivedi, Gang Tan, and Saeid Tizpaz-Niari. 2025. Uncovering Discrimination Clusters: Quantifying and Explaining Systematic Fairness Violations. In 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). 1680–1692. doi:10.1109/ASE63991.2025.00141 Becker and Kohavi (1996) Barry Becker and Ronny Kohavi. 1996. Adult. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5XW20. Bellamy et al. (2019) R. K. E. Bellamy, K. Dey, M. Hind, et al. 2019. AI Fairness 360: An extensible toolkit for detecting and mitigating algorithmic bias. IBM Journal of Research and Development 63, 4/5 (2019), 4:1–4:15. doi:10.1147/JRD.2019.2942287 Biswas and Rajan (2023) Sumon Biswas and Hridesh Rajan. 2023. Fairify: Fairness Verification of Neural Networks. In Proceedings of the 45th International Conference on Software Engineering (Melbourne, Victoria, Australia) (ICSE ’23). IEEE Press, 1546–1558. doi:10.1109/ICSE48619.2023.00134 Chakraborty et al. (2021) Joymallya Chakraborty, Suvodeep Majumder, and Tim Menzies. 2021. Bias in Machine Learning Software: Why? How? What to Do?. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2021). Association for Computing Machinery, New York, NY, USA, 429–440. doi:10.1145/3468264.3468537 Chakraborty et al. (2020) Joymallya Chakraborty, Suvodeep Majumder, Zhe Yu, and Tim Menzies. 2020. Fairway: a way to build fair ML software. In Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (Virtual Event, USA) (ESEC/FSE 2020). Association for Computing Machinery, New York, NY, USA, 654–665. doi:10.1145/3368089.3409697 Chouldechova (2017) Alexandra Chouldechova. 2017. Fair Prediction with Disparate Impact: A Study of Bias in Recidivism Prediction Instruments. Big Data 5, 2 (2017), 153–163. doi:10.1089/big.2016.0047 Dasu et al. (2024) Vishnu Asutosh Dasu, Ashish Kumar, Saeid Tizpaz-Niari, and Gang Tan. 2024. NeuFair: Neural Network Fairness Repair with Dropout. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 1541–1553. doi:10.1145/3650212.3680380 Dasu et al. (2026) Vishnu Asutosh Dasu, Md Rafi Ur Rashid, Vipul Gupta Saeid Tizpaz-Niari, and Gang Tan. 2026. Attention Pruning: Automated Fairness Repair of Language Models via Surrogate Simulated Annealing. In 48th International Conference on Software Engineering (ICSE). To appear. Dwork et al. (2012) Cynthia Dwork, Moritz Hardt, Toniann Pitassi, Omer Reingold, and Richard Zemel. 2012. Fairness Through Awareness. In Proceedings of the 3rd Innovations in Theoretical Computer Science Conference (ITCS). 214–226. doi:10.1145/2090236.2090255 Fan et al. (2022) Ming Fan, Wenying Wei, Wuxia Jin, Zijiang Yang, and Ting Liu. 2022. Explanation-guided fairness testing through genetic algorithm. In Proceedings of the 44th International Conference on Software Engineering (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 871–882. doi:10.1145/3510003.3510137 Galhotra et al. (2017) Sainyam Galhotra, Yuriy Brun, and Alexandra Meliou. 2017. Fairness testing: testing software for discrimination. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE’17). ACM, 498–510. doi:10.1145/3106237.3106277 Gao et al. (2022) Xuanqi Gao, Juan Zhai, Shiqing Ma, Chao Shen, Yufei Chen, and Qian Wang. 2022. FairNeuron: improving deep neural network fairness with adversary games on selective neurons. In Proceedings of the 44th International Conference on Software Engineering (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 921–933. doi:10.1145/3510003.3510087 Hardt et al. (2016) Moritz Hardt, Eric Price, and Nathan Srebro. 2016. Equality of Opportunity in Supervised Learning. In Proceedings of the 30th International Conference on Neural Information Processing Systems (NIPS). 3323–3331. Hofmann (1994) Hans Hofmann. 1994. Statlog (German Credit Data). UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5NC77. Johnson and Brun (2022) Brittany Johnson and Yuriy Brun. 2022. Fairkit-learn: a fairness evaluation and comparison toolkit. In Proceedings of the ACM/IEEE 44th International Conference on Software Engineering: Companion Proceedings (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 70–74. doi:10.1145/3510454.3516830 Kleinberg et al. (2016) Jon Kleinberg, Sendhil Mullainathan, and Manish Raghavan. 2016. Inherent Trade-Offs in the Fair Determination of Risk Scores. arXiv:1609.05807 [cs.LG] https://arxiv.org/abs/1609.05807 Li et al. (2023) Tianlin Li, Xiaofei Xie, Jian Wang, Qing Guo, Aishan Liu, Lei Ma, and Yang Liu. 2023. Faire: Repairing Fairness of Neural Networks via Neuron Condition Synthesis. ACM Trans. Softw. Eng. Methodol. 33, 1, Article 21 (Nov. 2023), 24 pages. doi:10.1145/3617168 Lundberg and Lee (2017) Scott M. Lundberg and Su-In Lee. 2017. A unified approach to interpreting model predictions. In Proceedings of the 31st International Conference on Neural Information Processing Systems (Long Beach, California, USA) (NIPS’17). Curran Associates Inc., Red Hook, NY, USA, 4768–4777. Monjezi et al. (2025) Verya Monjezi, Ashutosh Trivedi, Vladik Kreinovich, and Saeid Tizpaz-Niari. 2025. Fairness Testing through Extreme Value Theory. In Proceedings of the IEEE/ACM 47th International Conference on Software Engineering (Ottawa, Ontario, Canada) (ICSE ’25). IEEE Press, 1501–1513. doi:10.1109/ICSE55347.2025.00070 Monjezi et al. (2023) Verya Monjezi, Ashutosh Trivedi, Gang Tan, and Saeid Tizpaz-Niari. 2023. Information-Theoretic Testing and Debugging of Fairness Defects in Deep Neural Networks. In Proceedings of the 45th International Conference on Software Engineering (ICSE). 1571–1582. doi:10.1109/ICSE48619.2023.00136 Moro et al. (2014) S. Moro, P. Rita, and P. Cortez. 2014. Bank Marketing. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5K306. Rathod and Tizpaz-Niari (2026) Archit Rathod and Saeid Tizpaz-Niari. 2026. Reproduction Package for Article ‘FairLint-DL: An IDE-Native Tool for Fairness Debugging of Deep Learning Software’. Zenodo. doi:10.5281/zenodo.21142733 Ribeiro et al. (2016) Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. 2016. “Why Should I Trust You?”: Explaining the Predictions of Any Classifier. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD). 1135–1144. doi:10.1145/2939672.2939778 Robles Herrera et al. (2024) Salvador Robles Herrera, Verya Monjezi, Vladik Kreinovich, Ashutosh Trivedi, and Saeid Tizpaz-Niari. 2024. Predicting Fairness of ML Software Configurations. In Proceedings of the 20th International Conference on Predictive Models and Data Analytics in Software Engineering (Porto de Galinhas, Brazil) (PROMISE 2024). Association for Computing Machinery, New York, NY, USA, 56–65. doi:10.1145/3663533.3664040 Sun et al. (2022) Bing Sun, Jun Sun, Long H. Pham, and Jie Shi. 2022. Causality-based neural network repair. In Proceedings of the 44th International Conference on Software Engineering (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 338–349. doi:10.1145/3510003.3510080 Tizpaz-Niari et al. (2022) Saeid Tizpaz-Niari, Ashish Kumar, Gang Tan, and Ashutosh Trivedi. 2022. Fairness-aware configuration of machine learning libraries. In Proceedings of the 44th International Conference on Software Engineering (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 909–920. doi:10.1145/3510003.3510202 Udeshi et al. (2018) Sakshi Udeshi, Pryanshu Arora, and Sudipta Chattopadhyay. 2018. Automated directed fairness testing. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering (Montpellier, France) (ASE ’18). Association for Computing Machinery, New York, NY, USA, 98–108. doi:10.1145/3238147.3238165 Wang et al. (2024) Zhaohui Wang, Min Zhang, Jingran Yang, Bojie Shao, and Min Zhang. 2024. MAFT: Efficient Model-Agnostic Fairness Testing for Deep Neural Networks via Zero-Order Gradient Search. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (Lisbon, Portugal) (ICSE ’24). Association for Computing Machinery, New York, NY, USA, Article 121, 12 pages. doi:10.1145/3597503.3639181 Weerts et al. (2023) Hilde Weerts, Miroslav Dudík, Richard Edgar, Adrin Jalali, Roman Lutz, and Michael Madaio. 2023. Fairlearn: Assessing and Improving Fairness of AI Systems. Journal of Machine Learning Research 24, 1, Article 257 (2023). Wexler et al. (2019) James Wexler, Mahima Pushkarna, Tolga Bolukbasi, Martin Wattenberg, Fernanda B. Viégas, and Jimbo Wilson. 2019. The What-If Tool: Interactive Probing of Machine Learning Models. IEEE Transactions on Visualization and Computer Graphics 26 (2019), 56–65. doi:10.1109/TVCG.2019.2934619 Xiao et al. (2023) Yisong Xiao, Aishan Liu, Tianlin Li, and Xianglong Liu. 2023. Latent Imitator: Generating Natural Individual Discriminatory Instances for Black-Box Fairness Testing. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis (Seattle, WA, USA) (ISSTA 2023). Association for Computing Machinery, New York, NY, USA, 829–841. doi:10.1145/3597926.3598099 Yu et al. (2025) Normen Yu, Luciana Carreon, Gang Tan, and Saeid Tizpaz-Niari. 2025. FairLay-ML: Intuitive Debugging of Fairness in Data-Driven Social-Critical Software. In Proceedings of the 47th International Conference on Software Engineering (ICSE), Companion. IEEE, 25–28. doi:10.1109/ICSE-COMPANION66252.2025.00016 Zhang and Harman (2021) Jie M. Zhang and Mark Harman. 2021. "Ignorance and Prejudice" in Software Fairness. In 43rd IEEE/ACM International Conference on Software Engineering, ICSE 2021, Madrid, Spain, 22-30 May 2021. IEEE, 1436–1447. doi:10.1109/ICSE43902.2021.00129 Zhang et al. (2021) Lingfeng Zhang, Yueling Zhang, and Min Zhang. 2021. Efficient white-box fairness testing through gradient search. In Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis (Virtual, Denmark) (ISSTA 2021). Association for Computing Machinery, New York, NY, USA, 103–114. doi:10.1145/3460319.3464820 Zhang and Sun (2022) Mengdi Zhang and Jun Sun. 2022. Adaptive fairness improvement based on causality analysis. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (Singapore, Singapore) (ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 6–17. doi:10.1145/3540250.3549103 Zhang et al. (2020) Peixin Zhang, Jingyi Wang, Jun Sun, Guoliang Dong, Xinyu Wang, Xingen Wang, Jin Song Dong, and Ting Dai. 2020. White-box fairness testing through adversarial sampling. In Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering (Seoul, South Korea) (ICSE ’20). Association for Computing Machinery, New York, NY, USA, 949–960. doi:10.1145/3377811.3380331 Zhao et al. (2024) Zhenjiang Zhao, Takahisa Toda, and Takashi Kitamura. 2024. Approximation-guided Fairness Testing through Discriminatory Space Analysis. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering (Sacramento, CA, USA) (ASE ’24). Association for Computing Machinery, New York, NY, USA, 1007–1018. doi:10.1145/3691620.3695481 Zheng et al. (2022) Haibin Zheng, Zhiqing Chen, Tianyu Du, Xuhong Zhang, Yao Cheng, Shouling Ji, Jingyi Wang, Yue Yu, and Jinyin Chen. 2022. NeuronFair: interpretable white-box fairness testing through biased neuron identification. In Proceedings of the 44th International Conference on Software Engineering (Pittsburgh, Pennsylvania) (ICSE ’22). Association for Computing Machinery, New York, NY, USA, 1519–1531. doi:10.1145/3510003.3510123