Section 1.1: Causalinference

Causalinference is a user-friendly Python library designed for causal analysis. It offers a variety of statistical methods tailored for causal learning, including:

• Estimating propensity scores and subclassification
• Enhancing covariate balance through trimming
• Assessing treatment effects
• Evaluating the overlap in covariate distributions

For a more detailed understanding of each feature, you can visit the package's webpage.

To get started with Causalinference, you’ll first need to install the package:

pip install causalinference

Once installed, you can implement a causal model using random data generated by the package:

from causalinference import CausalModel

from causalinference.utils import random_data

# Y is the outcome, D is treatment status, and X is the independent variable

Y, D, X = random_data()

causal = CausalModel(Y, D, X)

The CausalModel class will analyze your dataset. To obtain a statistical summary, you can use the following command:

print(causal.summary_stats)

The crux of causal analysis is evaluating treatment effect information, which can be accomplished using the Ordinary Least Squares method:

causal.est_via_ols()

print(causal.estimates)

Terms like ATE, ATC, and ATT represent Average Treatment Effect, Average Treatment Effect for Control, and Average Treatment Effect for Treated, respectively. This allows us to gauge the effectiveness of the treatment compared to a control group.

Additionally, using the propensity score method, you can determine the probability of treatment based on independent variables:

causal.est_propensity_s()

print(causal.propensity)

For further exploration of methods, check out the Causalinference website.

The first video, "An introduction to Causal Inference with Python," provides insights into accurately estimating cause and effect relationships.

Section 1.2: Causallib

Causallib, developed by IBM, integrates causal analysis with the Scikit-Learn API, making it a powerful tool for complex learning models using the fit-and-predict paradigm. One of the standout features of Causallib is the extensive array of example notebooks available for learners.

To begin, install Causallib:

pip install causallib

Next, utilize an example dataset from Causallib to conduct causal analysis with a Scikit-Learn model:

from sklearn.linear_model import LogisticRegression

from causallib.estimation import IPW

from causallib.datasets import load_nhefs

data = load_nhefs()

ipw = IPW(LogisticRegression())

ipw.fit(data.X, data.a)

potential_outcomes = ipw.estimate_population_outcome(data.X, data.a, data.y)

effect = ipw.estimate_effect(potential_outcomes[1], potential_outcomes[0])

This code analyzes a follow-up study examining the impact of smoking on health. The potential outcomes reveal average weight differences based on smoking status, indicating a significant effect of the treatment.

For more learning materials, visit the Causallib notebook page.

The second video, "Full Tutorial: Causal Machine Learning in Python," features an in-depth exploration of causal machine learning techniques.

Section 1.3: Causalimpact

Causalimpact is another Python library that estimates the causal effects of time series interventions. It compares treatment responses before and after an intervention, utilizing a Bayesian structural time-series model to predict the counterfactual scenario.

To use Causalimpact, first install it:

pip install causalimpact

Next, create simulated data for analysis:

import numpy as np

from statsmodels.tsa.arima_process import arma_generate_sample

from causalimpact import CausalImpact

np.random.seed(1)

x1 = arma_generate_sample(ar=[0.999], ma=[0.9], nsample=100) + 100

y = 1.2 * x1 + np.random.randn(100)

y[71:100] += 10

data = pd.DataFrame(np.array([y, x1]).T, columns=["y", "x1"])

pre_period = [0, 69]

post_period = [71, 99]

You can run the analysis by specifying the pre- and post-intervention periods:

impact = CausalImpact(data, pre_period, post_period)

impact.run()

impact.plot()

The resulting plot illustrates actual data versus counterfactual predictions, allowing for the assessment of the intervention's impact.

For detailed results, you can use:

impact.inferences

impact.summary()

To learn more about time-intervention causal analysis, refer to the documentation.

Section 1.4: DoWhy

DoWhy is a cutting-edge Python package that simplifies causal analysis through a straightforward API and comprehensive documentation. According to its documentation, DoWhy follows a four-step process:

1. Model a causal inference problem using specified assumptions.
2. Identify an expression for the causal effect based on those assumptions.
3. Estimate the expression using statistical methods.
4. Validate the estimate's reliability.

To initiate an analysis using DoWhy, install it first:

pip install dowhy

Then, load a sample dataset:

from dowhy import CausalModel

import dowhy.datasets

data = dowhy.datasets.linear_dataset(

beta=10,

num_common_causes=5,

num_instruments=2,

num_samples=10000,

treatment_is_binary=True)

Next, create a causal model based on the data and a given graph:

model = CausalModel(

data=data["df"],

treatment=data["treatment_name"],

outcome=data["outcome_name"],

graph=data["gml_graph"])

model.view_model()

Identify the causal effect:

estimands = model.identify_effect()

Estimate the strength of the causal effect statistically:

estimate = model.estimate_effect(identified_estimand, method_name="backdoor.propensity_score_matching")

Finally, validate the assumptions through a robustness check:

refute_results = model.refute_estimate(identified_estimand, estimate, method_name="random_common_cause")

DoWhy's documentation is a rich resource for further education on causal analysis.