dowhy
v0.11.1: Bug fixes and improvements
Pour plus d'exemples de cahiers, voyez ici!
La prise de décision consiste à comprendre comment différentes variables s'affichent et prédire le résultat lorsque certaines d'entre elles sont changées en nouvelles valeurs. Par exemple, étant donné une variable de résultat, on peut être intéressé à déterminer comment une ou des actions potentielles peuvent l'affecter, en comprenant ce qui a conduit à sa valeur actuelle ou simuler ce qui se passerait si certaines variables étaient modifiées. Répondre à ces questions nécessite un raisonnement causal. Dowhy est une bibliothèque Python qui vous guide à travers les différentes étapes du raisonnement causal et fournit une interface unifiée pour répondre aux questions causales.
Dowhy fournit une grande variété d'algorithmes pour l'estimation des effets, la prédiction, la quantification des influences causales, le diagnostic des structures causales, l'analyse des causes profondes, les interventions et les contrefactuels. Une caractéristique clé de Dowhy est son API de réfutation et de falsification qui peut tester les hypothèses causales pour toute méthode d'estimation, rendant ainsi l'inférence plus robuste et accessible aux non-experts.
Modèles causaux graphiques et résultats potentiels: le meilleur des deux mondes
Dowhy s'appuie sur deux des cadres les plus puissants pour l'inférence causale: les modèles causaux graphiques et les résultats potentiels. Pour l'estimation des effets, il utilise des critères basés sur des graphiques et le calcul DO pour modéliser les hypothèses et l'identification d'un effet causal non paramétrique. Pour l'estimation, il passe à des méthodes basées principalement sur des résultats potentiels.
Pour les questions causales au-delà de l'estimation de l'effet, il utilise la puissance des modèles causaux graphiques en modélisant le processus de génération de données via des mécanismes causaux explicites à chaque nœud, qui, par exemple, débloque les capacités d'attribuer les effets observés à des variables particulières ou estiment les contrefactuels ponctuels.
Pour une introduction rapide à l'inférence causale, consultez Amit-Sharma / causal Inference-tutorial, nous avons également donné un tutoriel plus complet lors de la conférence ACM Knowledge Discovery and Data Mining (KDD 2018): causalinference.gitlab.io/kdd-tutorial. Pour une introduction aux quatre étapes de l'inférence causale et à ses implications pour l'apprentissage automatique, vous pouvez accéder à ce tutoriel vidéo à partir du webinaire Dowhy Microsoft Research et pour une introduction à l'API du modèle causal graphique, voir la présentation PyCon sur l'analyse des causes profondes avec le dowhy.
Dowhy soutient les tâches causales suivantes:
Pour plus de détails et comment utiliser ces méthodes dans la pratique, consultez la documentation sur https://py-why.github.io/dowhy
Dowhy prend en charge Python 3.8+. Pour installer, vous pouvez utiliser PIP, poésie ou conda.
Dernière version
Installez la dernière version à l'aide de PIP.
pip install dowhyInstallez la dernière version en utilisant la poésie.
poetry add dowhyInstallez la dernière version en utilisant conda.
conda install -c conda-forge dowhy Si vous faites face à des problèmes de "Environnement de résolution" avec Conda, essayez conda update --all puis installez Dowhy. Si cela ne fonctionne pas, utilisez conda config --set channel_priority false et essayez de réinstaller. Si le problème persiste, veuillez ajouter votre problème ici.
Version de développement
Si vous préférez utiliser la dernière version Dev, votre outil de gestion des dépendances devra pointer de notre référentiel GitHub.
pip install git+https://github.com/py-why/dowhy@mainExigences
Dowhy nécessite quelques dépendances. Des détails sur des versions spécifiques peuvent être trouvés dans pyproject.toml, dans la section Tool.Poetry.Dependces.
Si vous rencontrez des problèmes, essayez d'installer des dépendances manuellement.
pip install ' <dependency-name>==<version> 'Facultativement, si vous souhaitez saisir des graphiques au format DOT, installez Pydot (ou Pygraphviz).
Pour des graphiques plus beaux, vous pouvez éventuellement installer Pygraphviz. Pour continuer, installez d'abord Graphviz puis Pygraphviz (sur Ubuntu et Ubuntu WSL).
Note
L'installation de Pygraphviz peut causer des problèmes sur certaines plates-formes. Une façon qui fonctionne pour la plupart des distributions Linux est d'installer d'abord Graphviz, puis de pygraphviz comme indiqué ci-dessous. Sinon, veuillez consulter la documentation de Pygraphviz.
sudo apt install graphviz libgraphviz-dev graphviz-dev pkg-config
pip install --global-option=build_ext
--global-option= " -I/usr/local/include/graphviz/ "
--global-option= " -L/usr/local/lib/graphviz " pygraphvizLa plupart des tâches causales de Dowhy ne nécessitent que quelques lignes de code pour écrire. Ici, nous estimons l'exemple l'effet causal d'un traitement sur une variable de résultat:
from dowhy import CausalModel
import dowhy . datasets
# Load some sample data
data = dowhy . datasets . linear_dataset (
beta = 10 ,
num_common_causes = 5 ,
num_instruments = 2 ,
num_samples = 10000 ,
treatment_is_binary = True )Un graphique causal peut être défini d'une manière différente, mais la manière la plus courante est via NetworkX. Après le chargement des données, nous utilisons les quatre principales opérations pour l'estimation de l'effet dans Dowhy: modèle , identifier , estimer et réfuter :
# I. Create a causal model from the data and given graph.
model = CausalModel (
data = data [ "df" ],
treatment = data [ "treatment_name" ],
outcome = data [ "outcome_name" ],
graph = data [ "gml_graph" ]) # Or alternatively, as nx.DiGraph
# II. Identify causal effect and return target estimands
identified_estimand = model . identify_effect ()
# III. Estimate the target estimand using a statistical method.
estimate = model . estimate_effect ( identified_estimand ,
method_name = "backdoor.propensity_score_matching" )
# IV. Refute the obtained estimate using multiple robustness checks.
refute_results = model . refute_estimate ( identified_estimand , estimate ,
method_name = "random_common_cause" )Dowhy souligne l'interprétabilité de sa sortie. À tout moment de l'analyse, vous pouvez inspecter les hypothèses non testées, les estimations identifiées (le cas échéant) et l'estimation (le cas échéant). Voici un échantillon de sortie de l'estimateur de régression linéaire:
Pour un exemple de code complet, consultez le démarrage avec Dowhy Notebook.
Vous pouvez également utiliser les méthodes d'estimation de l'effet de traitement moyen conditionnel (CATE) de l'ECONML, comme le montre le cahier des effets de traitement conditionnel. Voici un extrait de code.
from sklearn . preprocessing import PolynomialFeatures
from sklearn . linear_model import LassoCV
from sklearn . ensemble import GradientBoostingRegressor
dml_estimate = model . estimate_effect ( identified_estimand , method_name = "backdoor.econml.dml.DML" ,
control_value = 0 ,
treatment_value = 1 ,
target_units = lambda df : df [ "X0" ] > 1 ,
confidence_intervals = False ,
method_params = {
"init_params" :{ 'model_y' : GradientBoostingRegressor (),
'model_t' : GradientBoostingRegressor (),
'model_final' : LassoCV (),
'featurizer' : PolynomialFeatures ( degree = 1 , include_bias = True )},
"fit_params" :{}})Le cadre du modèle causal graphique de Dowhy propose des outils puissants pour répondre aux questions causales au-delà de l'estimation de l'effet. Il est basé sur le cadre du modèle causal graphique de Pearl et modélise le processus de génération de données causal de chaque variable explicitement via des mécanismes causaux pour soutenir une large gamme d'algorithmes causaux. Pour plus de détails, consultez les éléments du livre de l'inférence causale.
Des requêtes causales complexes, telles que l'attribution des anomalies observées aux nœuds du système, peuvent être effectuées avec seulement quelques lignes de code:
import networkx as nx , numpy as np , pandas as pd
from dowhy import gcm
# Let's generate some "normal" data we assume we're given from our problem domain:
X = np . random . normal ( loc = 0 , scale = 1 , size = 1000 )
Y = 2 * X + np . random . normal ( loc = 0 , scale = 1 , size = 1000 )
Z = 3 * Y + np . random . normal ( loc = 0 , scale = 1 , size = 1000 )
data = pd . DataFrame ( dict ( X = X , Y = Y , Z = Z ))
# 1. Modeling cause-effect relationships as a structural causal model
# (causal graph + functional causal models):
causal_model = gcm . StructuralCausalModel ( nx . DiGraph ([( 'X' , 'Y' ), ( 'Y' , 'Z' )])) # X -> Y -> Z
gcm . auto . assign_causal_mechanisms ( causal_model , data )
# 2. Fitting the SCM to the data:
gcm . fit ( causal_model , data )
# Optional: Evaluate causal model
print ( gcm . evaluate_causal_model ( causal_model , data ))
# Step 3: Perform a causal analysis.
# results = gcm.<causal_query>(causal_model, ...)
# For instance, root cause analysis:
anomalous_sample = pd . DataFrame ( dict ( X = [ 0.1 ], Y = [ 6.2 ], Z = [ 19 ])) # Here, Y is the root cause.
# "Which node is the root cause of the anomaly in Z?":
anomaly_attribution = gcm . attribute_anomalies ( causal_model , "Z" , anomalous_sample )
# Or sampling from an interventional distribution. Here, under the intervention do(Y := 2).
samples = gcm . interventional_samples ( causal_model , interventions = { 'Y' : lambda y : 2 }, num_samples_to_draw = 100 )Le framework GCM offre de nombreuses autres fonctionnalités au-delà de ces exemples. Pour un exemple de code complet, consultez l'exemple de la boutique en ligne.
Pour plus de fonctionnalités, des exemples d'applications de Dowhy et des détails sur les sorties, consultez le guide de l'utilisateur ou les ordinateurs portables Jupyter.
Blog de recherche Microsoft | Tutoriel vidéo pour l'estimation des effets | Tutoriel vidéo pour l'analyse des causes profondes | Papier Arxiv | Papier ArXIV (extension du modèle causal graphique) | Diapositives
Si vous trouvez Dowhy utile pour votre travail, veuillez citer les deux références suivantes:
Bibtex:
@article {Dowhy,
title = {Dowhy: une bibliothèque de bout en bout pour l'inférence causale},
auteur = {Sharma, Amit et Kiciman, Emre},
journal = {arXiv Preprint Arxiv: 2011.04216},
année = {2020}
}
@article {JMLR: V25: 22-1258,
Auteur = {Patrick BL {{ "O}} Baum et Peter G {{" O}} TZ et Kailash Budhathoki et Atalanti A. Mastakouri et Dominik Janzing},
Titre = {Dowhy-GCM: une extension de Dowhy pour l'inférence causale dans les modèles causaux graphiques},
Journal = {Journal of Machine Learning Research},
année = {2024},
volume = {25},
nombre = {147},
pages = {1-7},
url = {http://jmlr.org/papers/v25/22-1258.html}
}
Si vous rencontrez un problème ou si vous avez une demande spécifique pour Dowhy, veuillez soulever un problème.
Ce projet accueille les contributions et les suggestions. Pour un guide de contribution et une liste de tous les contributeurs, consultez contribution.md et nos documents pour contribuer au code. Notre code de conduite de contributeur est disponible ici.
