Repousser les limites d’explicabilité — un guide avancé de SHAP
Cet article est un guide des fonctionnalités avancées et moins connues de la librairie python SHAP. Il se base sur un exemple de classification de données tabulaires.
D’abord, parlons de la motivation et intérêt pour l’explicabilité Saegus qui a motivé et financé mes explorations.
Explicabilité — la théorie
L’explicabilité des algorithmes prend de plus en plus de place dans les débats autour de la Data Science. On sait que les algorithmes sont puissants, on sait qu’ils peuvent nous assister dans de nombreuses tâches : prédiction de prix, classification de documents, recommandation de vidéos.
Dorénavant, on se pose de plus en plus de questions sur cette prédiction :
- est-elle éthique ?
- est-elle touchée par des biais ?
- est-elle prise pour de bonnes raisons ?
Dans de nombreux secteurs comme la médecine, la banque ou encore l’assurance, l’emploi d’algorithmes peut avoir lieu si, et seulement si, il est possible de tracer et expliquer (ou encore mieux interpréter) les décisions de ces dits algorithmes.
Parenthèse sur le vocabulaire
Dans cet article nous souhaitons distinguer les termes :
Explicabilité: possibilité d’expliquer d’un point de vue technique la prédiction d’un algorithme.
Interprétabilité: capacité d’expliquer ou de fournir du sens en termes compréhensibles par un être humain.
Transparence: un modèle est considéré comme transparent s’il est compréhensible en soi.
Pourquoi l’interprétabilité est si importante ?
L’interprétabilité aide à garantir l’impartialité dans la prise de décision, c’est-à-dire à détecter et, par conséquent, à corriger les biais dans l’ensemble des données d’entrainement. De plus, elle facilite la robustesse en mettant en évidence les perturbations adverses potentielles qui pourraient changer la prédiction. Elle peut également agir comme une assurance que seules des variables significatives infèrent le résultat.
Parfois, il serait plus judicieux d’abandonner l’approche machine learning, d’utiliser les algorithmes déterministes basées sur les règles justifiées par le métier ou la legislation [1].
Néanmoins, il est trop tentant d’accéder aux performances des algorithmes de machine learning qui peuvent proposer une haute efficacité. On peut parler du compromis entre la performance et l’explicabilité. Ce compromis consiste en abandon de modèles les plus complexes comme réseaux de neurones pour les algorithmes plus simples que l’on peut expliquer.
![Comme décrit dans [2] relation entre l’interpretabilité et la pertinence (accuracy) du modèle.](https://miro.medium.com/v2/resize:fit:1400/format:webp/0*SqScgDAgjvZ8HiCg.png)
Pour atteindre ces objectifs, un nouveau domaine a émergé: XAI (Explainable Artificial Intelligence), qui vise à produire des algorithmes à la fois puissants et explicables.
De nombreux frameworks ont été proposés pour aider à expliquer les algorithmes non-transparents. Une très bonne présentation de ces méthodes se trouve dans livre blanc de Cloudera [3]. Dans cet article nous allons traiter une des frameworks les plus utilisés : SHAP.
Pour qui ?
Des profils différents intéressés par l’explicabilité ou l’interprétabilité ont été identifés:
- Expert métier/utilisateur du modèle — afin de faire confiance au modèle, comprendre la causalité de la prédiction
- Organes régulateurs afin de certifier la conformité avec la législation, faire un audit
- Managers et executive board afin d'évaluer la conformité réglementaire, comprendre les applications d’IA d’entreprise
- Utilisateurs impactés par les décisions du modèle afin de comprendre la situation, vérifier les décisions
- Data scientist, développeur, PO afin d’assurer/améliorer performance du produit, trouver des nouvelles fonctionnalités, expliquer le fonctionnement/prédictions aux supérieurs
Afin de rendre possible l’accès à l’explicabilité aux personnes peu techniques, tout d’abord le créateur : un data scientist/développeur doit être à l’aise avec les outils d’explicabilité. Le data scientist va s’en servir en premier lieu pour comprendre, améliorer son modèle et ensuite pour communiquer avec ses supérieurs et les organes régulateurs.
Récemment, les outils d’explicabilité sont rendus de plus en plus accessibles.
Par exemple Dataiku — plateforme de ML — a ajouté dans sa dernière version 7.0 publiée le 2 mars 2020 des outils d’explicabilité : Shapley values et “The Individual Conditional Expectation” (ICE)
Azure ML propose également leur propre variante de Shap et autres méthodes avec des tableaux de bord interactifs.
Il existe aussi de webapps open-source comme celle-ci décrite dans l’article medium [4] qui facilitent l’exploration de la libraire SHAP.
Ces outils, très intéressants pour avoir un aperçu rapide d’interprétablité, ne donnent pas forcément une compréhension du plein potentiel de la librairie SHAP. Peu permettent d’explorer les valeurs d’interactions ou utiliser différents sets de fond (background) ou affichage (display).
J’ai investigué le framework SHAP et je vous présente mes remarques et l’utilisation de fonctionnalités moins connues, disponibles dans la version officielle de la librairie en open source. Je propose également quelques visualisations interactives faciles à intégrer dans vos projets.
Explicabilité — la pratique
La plupart de data scientists ont déjà entendu parler du framework SHAP.
Dans ce post, nous n’allons pas vous expliquer en détail comment se font les calculs derrière la libraire. De nombreuses ressources sont disponibles en ligne comme la documentation de SHAP [5], les publications d’auteurs de la librairie [6,7], le superbe livre “Interpretable Machine Learning” [8] et nombreux articles medium [9,10,11].
En résumé, les valeurs de Shapley calculent l’importance d’une variable en comparant ce qu’un modèle prédit avec et sans cette variable. Cependant, étant donné que l’ordre dans lequel un modèle voit les variables peut affecter ses prédictions, cela se fait dans tous les ordres possibles, afin que les fonctionnalités soient comparées équitablement. Cette approche est inspirée de la théorie des jeux.
Après avoir travaillé avec des nombreux clients, par exemple dans le secteur bancaire et assuranciel, on peut se rendre compte que leurs data scientists ont du mal à exploiter le potentiel de SHAP au maximum. Ils ne savaient pas comment cet outil pouvait vraiment être utile pour comprendre un modèle et comment l’utiliser pour aller plus loin que simplement extraire l’importance de variables.
Le diable est dans les détails
SHAP vient avec un ensemble de visualisations qui sont assez complexes et pas toujours intuitives même pour un data scientist.
En plus de cela, il existe plusieurs nuances techniques pour pouvoir utiliser SHAP avec vos données. L’article sur le blog de Francesco Porchetti [12] exprime quelques-unes de ces frustrations en explorant les libraries SHAP, LIME, PDPbox (PDP et ICE) et ELI5.
Chez Saegus, j’ai travaillé sur la construction d’une formation qui vise à donner plus de clarté au framework SHAP et à faciliter la prise en main de cet outil.
Dans ce post je voudrais vous partager quelques observations collectionnées au long de ce process.
SHAP s’utilise pour expliquer un modèle existant. Prenant un cas de classification binaire construite avec un modèle sklearn. On entraine, tune et teste notre modèle. Ensuite on peut utiliser nos données et le modèle pour créer un modèle supplémentaire de SHAP qui explique notre modèle de classification.
Vocabulaire
Il est important de comprendre tous les briques qui composent une explication de SHAP. Souvent, en utilisant les valeurs par défaut des paramètres, la complexité des choix que nous faisons reste obscure.
explications globales
explications concernant fonctionnement du modèle de point de vue général
explication locales
explications du modèle pour un instance
explainer (shap.explainer_type(params))
type d’algorithme d’explicabilité à choisir en fonction du modèle utilisé. Les paramètres sont différents pour chaque type du modèle. Habituellement, il faut fournir, à minima, le modèle et les données d’entrainement.
base value (explainer.expected_value)
E(y_hat) est «la valeur qui serait prédite si nous ne connaissions aucune caractéristique (feature) de la sortie actuelle » c’est la prédiction moyenne ou mean(y_hat) pour le jeu de données d’entrainement ou le jeu de fond (background set). On peut l’appeler “valeur de référence”, c’est un scalaire (n).
Il est important de bien choisir son jeu de fond — si nous avons le jeu d’entrainement non-equilibré ceci va résulter en valeur de base placé parmi la majorité d’instances. Ceci peut être également un effet souhaité: par exemple si pour un crédit bancaire nous souhaitons répondre à la question: “en quoi le client en question est différent de clients qui ont eu l’accord pour le crédit?” ou bien “en quoi mon faux positif est différent des vrais positifs?”.
# equilibrated casebackground = X.sample(1000) #X is equilibrated # background used in explainer defines base value
explainer = shap.TreeExplainer(xgb_model,background,model_output="raw" )shap_values = explainer.shap_values(X)# background used in the plot, the points that are visible on the plotshap.summary_plot(shap_values,background, feature_names=background.columns)
…
# base value shiftedclass1 = X.loc[class1,:] #X is equilibrated# background from class 1 is used in explainer defines base value
explainer = shap.TreeExplainer(xgb_model,class1,model_output="raw" )shap_values = explainer.shap_values(X)# points from class 0 is used in the plot, the points that are visible on the plotshap.summary_plot(shap_values,X.loc[class0,:], feature_names=X.columns)
SHAPley values (explainer.shap_values(x))
la contribution moyenne de chaque variable à chaque prédiction pour chaque instance sur la base de toutes les configurations de variables (features) possibles. C’est une matrice (n,m) n — instances, m — features qui represente la contribution de chaque variable à chaque instance.
output value (pour une instance)
La valeur prédite par l’algorithme (peut-être la probabilité, logit ou valeurs bruts (raw) de sortie du modèle)
display features (n x m)
Une matrice de valeurs d’origine — avant la transformation/encoding/ingénierie de variables etc. qui peut être fournie à certains graphiques pour améliorer l'interprétation. Souvent négligé et indispensable pour donner une interprétation.
—
SHAPley values — les valeurs Shapley restent l’élément central. Une fois on se rend compte que ceci est simplement une matrice avec les mêmes dimensions que nos donées d’entrée et que nous pouvons l’analyser de différentes manières pour expliquer le modèle et pas seulement. On peut reduire ses dimensions, on peut faire du clustering, on peut l’utiliser pour créer de nouvelles varaibles. Une exploration intéressante décrite dans article [12] vise à améliorer la détection d’anomalies en utilisant autoencodeurs et SHAP. La librarie SHAP propose une exploration riche mais pas exchaustive à travers de visualisations.
Visualisations
La librairie SHAP propose de différentes visualisations. Une bonne explication sur la façon de lire les couleurs du “summary plot” se trouve dans cet aticle medium [14].
Le summary plot permet de voir les variables les plus importantes et l’amplitude de leur impact sur le modèle. Il peut prendre plusieurs formes graphiques et pour les modèles expliqués par TreeExplainer nous pouvons observer aussi les valeurs d’interactions utilisant le “compact dot” avec shap_interaction_values en input.
Le dependence plot permet d’analyser les variables deux par deux en suggérant une possiblité d’observation des interactions. Le scatter plot représente une dépendence entre une variable (en x) et les shapley values (en y) colorié par une deuxième variable (coleur).
A titre personnel, je trouve qu’une observation de relation à trois facteurs en même temps n’est pas intuitive pour le cerveau humain (du moins le mien). Je doute également qu’une observation de dépendance en observant les couleurs peut être scientifiquement exacte. Shap peut nous donner une relation d’interaction qui est calculée comme une corrélation entre les shapley values de la première variable et les valeurs de la deuxième variable. Si possible (pour TreeExplainer) il est plus judicieux d’utiliser les valeurs d’interaction de shapley pour observer les interactions.
Je propose une variante de dépendance plot interactive qui permet d’observer la relation entre une variable (en x), les valeurs de shapley (en y) et la prédiction (couleurs de l’histogramme). Ce qui me semble important dans cette version est la possibilité d’afficher sur le graphique les valeurs d’origine (Income en k USD) au lieu de l’espace normalisé utilisé par le modèle.
Pour les visualisations d’explications d’une instance il existe trois alternatives: force plot, decision plot et waterfall plot.
Pour une instance, ces trois représentations sont redondantes, elles représentent l’information de manière très similaire. En même temps, certains éléments de ces graphiques sont complémentaires. En mettant côte à côte les trois, j’ai l’impression de comprendre d’une manière plus intuitive le résultat. Le force plot est bon pour voir où se place le “output value” par rapport à la “base value”. Nous observons également quelles variables ont un impact positif (rouge) ou négatif (bleu) sur la prédiction et l’amplitude de cet impact. Le water plot permet aussi de voir l’amplitude et la nature d’impact d’une variable avec sa quantification. Il permet de voir également l’ordre d’importance des variables et les valeurs prises par chacune des variables pour l’instance étudiée. Le Decision plot permet d’observer l’amplitude de chaque changement, “une trajectoire” prise par une instance pour les valeurs des variables affichées.
En utilisant le force plot et le decision plot nous pouvons représenter plusieurs instances en même temps.
The force plot pour un ensemble des instances peut être comparé au dernier niveau d’un dendrogramme. Les échantillons sont groupés par similarité ou par variable sélectionnée. A mon avis, ce graphique est difficile à lire pour un échantillon aléatoire. Il est beaucoup plus parlant si nous représentons les cas contrastés ou avec une hypothèse derrière.
Le decision plot, pour un ensemble d’échantillons, devient vite encombrant si nous sélectionnons trop d’instances. Il est très utile pour observer ‘un écart de trajectoire’ ou des “trajectoires divergentes/convergentes” d’un groupe d’instances limité.
Explainers
Explainers sont les modèles qui sert à calculer les valeurs shapley. Le schémat ci-dessous présente différentes types d’Explainers. Le choix d’explainer dépend essentiellement du modèle d’apprentissagé selectionné. Pour les modèles linéaires, on utilise le “Linear Explainer”, pour les arbres de décisons et modèles type “ensemble” — “TreeExplainer”. “Kernel Explainer” est plus lent que les explainers cités ci-dessus.
En plus le “Tree Explainer” permet d’afficher les valeurs d’interactions (voir section suivante). Il permet aussi transformer le model output en probabilities ou logloss, ce qui est habile pour une meilleure compréhension du modèle ou pour comparer plusieurs modèles.
Le Kernel Explainer crée un modèle qui substitue le plus proche de notre modèle. On peut utiliser le Kernel Explainer pour expliquer les réseaux de neurones. Pour les modèles d’apprentissage profond, il existe le Deep Explainer et le Grandient Explainer. Pour cet article nous n’avons pas investigué l’explicabilité des réseaux de neurones.
Shapley values d’interactions
Une des propriétés qui permet d’aller plus loin dans l’analyse d’un modèle qui peut s’expliquer avec le “Tree Explainer” est le calcul des valeurs shapley d’interactions.
Ces valeurs permettent de quantifier l’impact d’une interaction entre deux variables sur la prédiction pour chaque instance. Comme la matrice des valeurs shapley a deux dimensions (instances x variables), les interactions sont un tensor avec trois dimensions (instances x variables x variables).
Voici comment les valeurs d’interactions aident à interpréter un modèle de classification binaire.
Je me suis servi d’un jeu de données Kaggle [15] qui represente une base de clients et la variable dépendante binaire: est-ce que le client a accepté le prêt personnel? NON/OUI (0/1).
J’ai entrainé plusieurs modèles, dont un modèle xgboost que nous avons traité avec le Tree Explainer.
Le dataset de fond était équilibré et représantant 40% du jeux de données.
# xgb - modèle entrainé# X_background - dataset de fondexplainer_raw = shap.TreeExplainer(xgb,X_background, model_output="raw", feature_perturbation="tree_path_dependent" )# projeter les instances de dataset de fondshap_values = explainer_raw.shap_values(X_background)# obtenir les valeurs d'interactionsshap_interaction_values = explainer_raw.shap_interaction_values(X_background)# dimensionsshap_values.shape
>>>(2543, 16)shap_interaction_values.shape
>>>(2543, 16, 16)shap.summary_plot(shap_interaction_values, X_background, plot_type="compact_dot")
Pour mieux explorer les interactions, une heatmap peut être très utile.
Sur le Summary_plot on observe l’importance de variables et l’importance de ces variables mais aussi les interactions. Les interactions apparait en double ce qui broute un peu la lecture.
Sur l’histogramme, on observe directement les interactions. Les plus fortes étant: Income-Education, Income — Family, Income — CCAvg et Family-Education, Income-Age.
Ensuite j’ai investigué les interactions deux par deux.
Pour comprendre la différence entre un dependence_plot et un dependence_plot des interactions voici les deux:
# dependence_plot classiqueshap.dependence_plot("Age", shap_values, features= X_background,display_features=X_background_display, interaction_index="Income")
# dependence_plot des interactions shap.dependence_plot(("Age","Income"), shap_interaction_values, features= X_background,display_features=X_background_display)
Même en utilisant le paramètre `display_features`, les valeurs de l’Age et de l’Income sont affichées dans l’espace transformée.
Pour ceci je propose une version interactive, qui affiche les valeurs non-transformées.
Et le code pour reproduire ce graphique:
Voici pour les interactions les plus fortes:
Income — Education
Sur ce graphique, nous remarquons qu’avec un niveau d’Education 1 (undergrad) le revenu bas (sous 100 k USD) est un facteur encourageant à prendre un crédit, et le revenu haut (plus de 120 k USD) est une interaction inhibitrice.
Pour les individus avec l’Education 2 & 3 (graduated & advanced/professional), l’effet d’interaction est un peu plus faible et contraire à celui pour l’Education == 1.
Pour la variable Family, nombre de personnes dans le foyer, l’interaction est positive quand le revenu est bas (sous 100 k USD) et famille comporte 1–2 membres. Pour les revenus plus hauts (> 120 k USD), pour famille de 1–2 membres a un effet négatif. Le contraire se passe pour les familles de 3–4 personnes.
L’interactions entre le revenu et credit card average spending est plus complexe. Pour le revenu bas (<100 k USD) et CCAvg bas (<4 k USD) l’interaction a un effet négatif, pour le revenu entre 50 et 110 k USD et le CCAvg 2–6 k USD l’effet est fortement positif, cela pourrait définir une cible potentielle pour la prospection sur le crédit selon ces deux axes. Pour les revenus hauts (> 120 k USD) , le CCAvg bas impacte positivement la prédiction de la classe 1, haut CCAvg a un faible effet négatif sur les prédictions, le CCAvg moyen a un plus fort impact impact négatif.
L’interaction entre deux facteur est un peu moins lisible. Pour une famille de 1 et 2 membres avec l’Education “undergrad”, l’interaction a un impact négatif. Pour une famille de 3–4 personnes l’effet est contraire.
Pour les revenus bas (< 70k USD), impact change lineairement avec l’âge, plus l’âge est haut, plus l’impact varie positivement. Pour les revenus hauts (>120 k USD), l’impact d’interaction est plus faible, à l’âge moyen (~40 ans) l’impact est légèrement positif, à l’âge bas l’impact est négatif et pour l’âge >45 l’impact est neutre.
Ces conclusions seraient plus compliquées à interpréter si les valeurs des variables n’avaient pas correspondues à des valeurs d’origine. Parler de l’âge en négatif ou de revenus dans unités. Représenter les explications dans une dimension compréhensible facilite l’interprétation.
Comparer les modèles
Dans certaines situations, nous pouvons être amenés à vouloir comparer les prédictions de différents modèles pour les mêmes instances. Comprendre pourquoi un modèles classifie l’instance correctement et l’autre non.
Pour commencer, on peut afficher les summary plots pour chaque modèle, regarder les importance de features et les distributions de valeurs shapley. Cela donne une prémière idée générale.
Decision plot permet de comparer sur le même graphique les prédictions de deifférents modèles pour la même instance.
Il suffit de créer un objet qui simule la classification multiclasses.
# on a trois modèles: xgb, gbt, rf# pour chaque nous construisons un explainer (*_explainer), on obtient les probabilités (*_probs), les prédictions (*_pred) et les valeurs shapley (*_values)#xgbxgb_explainer = shap.TreeExplainer(xgb, X_background, model_output="probability", feature_perturbation="interventional")
xgb_values = xgb_explainer.shap_values(X_background)
xgb_probs = xgb.predict_proba(pipeline_trans.transform(x_background))
xgb_pred = xgb.predict(pipeline_trans.transform(x_background))# rf rf_explainer = shap.TreeExplainer(rf, X_background, model_output="probability", feature_perturbation="interventional")
rf_values = rf_explainer.shap_values(X_background)
rf_probs = rf.predict_proba(pipeline_trans.transform(x_background))
rf_pred = rf.predict(pipeline_trans.transform(x_background))# gbtgbt_explainer = shap.TreeExplainer(gbt, X_background, model_output="probability", feature_perturbation="interventional")
gbt_values = gbt_explainer.shap_values(X_background)
gbt_probs = gbt.predict_proba(pipeline_trans.transform(x_background))
gbt_pred = gbt.predict(pipeline_trans.transform(x_background))######### on construit une liste qui simule la classification multiclassbase_values = [xgb_explainer.expected_value, rf_explainer.expected_value[1], gbt_explainer.expected_value]
shap_values = [xgb_values, rf_values[1], gbt_values]
predictions = [xgb_probs,rf_probs,gbt_probs]labels = ["xgb", "rf", "gbt"]# index d'instance# Plot
idx = 100shap.multioutput_decision_plot(base_values, shap_values, idx, feature_names=X_background.columns.to_list(),legend_labels=labels, legend_location='lower right')
La seule difficulté consiste à bien vérifier les dimensions de shapley values car pour certains modèles, shapley values sont calculées pour chaque classe, dans le cas de la classification binaire (classe 0 et 1) alors que pour d’autres on obtient une seule matrice qui correspond à la classe 1. Dans notre exemple, nous sélectionnons seconde matrice (index 1) pour random forest.
Simulations
Par défaut SHAP ne contiens pas de fonctions qui facilitent la réponse à la question “Et si?” : “Et si je pouvais gagner 10K USD annuel de plus, mon crédit serait-il accordé ?”
Néanmoins, il est possible d’effectuer les simulations en variant une variable et calculer les valeurs shapley hypothétiques.
explainer_margin_i = shap.TreeExplainer(xgb,X_background, model_output="raw", feature_perturbation="interventional" )idx = 100rg = range(1, 202, 10)r, R, hypothetical_shap_values, hypothetical_predictions, y_r = simulate_with_shap(x_background,100, "Income", rg ,explainer_margin_i, pipeline_trans=pipeline_trans)
J’ai crée une fonction `simulate_with_shap` qui simule différentes valeurs de la variable et calcule les valeurs hypothétiques de shapley.
Cette simulation permet de voir pour l’instance sélectionnée, si l’on fige toutes les variables à part de l’Income, comment on pourrait changer la prédiction et quel seraient les valeurs shapley pour ces nouveaux valeurs.
Il est possible de simuler les changements ‘variable par variable’, il serait intéressant de pouvoir en faire plusieurs simultanement.
Note finale
Les algorithmes d’IA prennent de plus en plus de place dans notre vie. L’explicabilité de prédictions est un sujet d’importance pour les data scientists, les décisionnels et les individus qui sont impactés par les prédictions.
Plusieurs frameworks ont été proposé afin de transformer les modèles non explicables en explicables. Un des frameworks les plus connus et plus utilisés est SHAP.
Malgré une très bonne documentation, il n’est pas évident de savoir comment exploiter en profondeur toutes ses fonctionnalités.
J’ai proposé quelques simples améliorations de graphiques et j’ai tenté de demontrer l’utilité de fonctionnalités moins connus et non-comprises dans la plupart d’utilisations standard de SHAP.
Remerciments
Je voudrais remercier à l’équipe Saegus DATA qui a participé à ce travail avec du bon conseil, notamment le manager Fréderic Brajon et Senior Consultant Manager Clément Moutard.
Reférences
[1] Stop Explaining Black Box Machine Learning Models for High Stakes Decisions and Use Interpretable Models Instead; Cynthia Rudin https://arxiv.org/pdf/1811.10154.pdf
[2] Explainable Artificial Intelligence (XAI): Concepts, Taxonomies, Opportunities and Challenges toward Responsible AI; Arrietaa et al. https://arxiv.org/pdf/1910.10045.pdf
[3] Cloudera Fast Forward Interpretability: https://ff06-2020.fastforwardlabs.com/?utm_campaign=Data_Elixir&utm_source=Data_Elixir_282
[5] https://github.com/slundberg/shap
[6] http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions
[7] https://www.nature.com/articles/s42256-019-0138-9
[8] https://christophm.github.io/interpretable-ml-book/
[9] https://towardsdatascience.com/shap-explained-the-way-i-wish-someone-explained-it-to-me-ab81cc69ef30
[10] https://medium.com/@gabrieltseng/interpreting-complex-models-with-shap-values-1c187db6ec83
[12] https://francescopochetti.com/whitening-a-black-box-how-to-interpret-a-ml-model/
[13] Explaining Anomalies Detected by Autoencoders Using SHAP; Antwarg et al. https://arxiv.org/pdf/1903.02407.pdf
