{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Python: Difference-in-Differences\n", "\n", "In this example, we illustrate how the [DoubleML](https://docs.doubleml.org/stable/index.html) package can be used to estimate the average treatment effect on the treated (ATT) under the conditional parallel trend assumption. The estimation is based on [Chang (2020)](https://doi.org/10.1093/ectj/utaa001), [Sant'Anna and Zhao (2020)](https://doi.org/10.1016/j.jeconom.2020.06.003) and [Zimmert et al. (2018)](https://arxiv.org/abs/1809.01643).\n", "\n", "In this example, we will adopt the notation of [Sant'Anna and Zhao (2020)](https://doi.org/10.1016/j.jeconom.2020.06.003).\n", "\n", "In the whole example our treatment and time variable $t\\in\\{0,1\\}$ will be binary. \n", "Let $D_i\\in\\{0,1\\}$ denote the treatment status of unit $i$ at time $t=1$ (at time $t=0$ all units are not treated) and let $Y_{it}$ be the outcome of interest of unit $i$ at time $t$.\n", "Using the potential outcome notation, we can write $Y_{it}(d)$ for the potential outcome of unit $i$ at time $t$ and treatment status $d$. Further, let $X_i$ denote a vector of pre-treatment covariates.\n", "In these difference-in-differences settings [Abadie (2005)](https://doi.org/10.1111/0034-6527.00321) showed that the ATTE\n", "\n", "$$\\theta = \\mathbb{E}[Y_{i1}(1)- Y_{i1}(0)|D_i=1]$$\n", "\n", "is identified when panel data are available or under stationarity assumptions for repeated cross-sections. Further, the basic assumptions are \n", "\n", " - **Parallel Trends:** We have $\\mathbb{E}[Y_{i1}(0) - Y_{i0}(0)|X_i, D_i=1] = \\mathbb{E}[Y_{i1}(0) - Y_{i0}(0)|X_i, D_i=0]\\quad a.s.$\n", "\n", "- **Overlap:** For some $\\epsilon > 0$, $P(D_i=1) > \\epsilon$ and $P(D_i=1|X_i) \\le 1-\\epsilon$ a.s.\n", "\n", "For a detailed explanation of the assumptions see e.g. [Sant'Anna and Zhao (2020)](https://doi.org/10.1016/j.jeconom.2020.06.003) or [Zimmert et al. (2018)](https://arxiv.org/abs/1809.01643).\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Panel Data (Repeated Outcomes)\n", "\n", "At first, we will consider two-period panel data, where we observe i.i.d. data $W_i = (Y_{i0}, Y_{i1}, D_i, X_i)$.\n", "\n", "### Data\n", "\n", "We will use the implemented data generating process make_did_SZ2020 to generate data according to the simulation in [Sant'Anna and Zhao (2020)](https://doi.org/10.1016/j.jeconom.2020.06.003) (Section 4.1). \n", "\n", "In this example, we will use dgp_tpye=4, which corresponds to the misspecified settings in [Sant'Anna and Zhao (2020)](https://doi.org/10.1016/j.jeconom.2020.06.003) (other data generating processes are also available via the dgp_type parameter). In all settings the true ATTE is zero." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "To specify a corresponding DoubleMLData object, we have to specify a single outcome y. For panel data, the outcome consists of the difference of \n", "\n", "$$\\Delta Y_i = Y_{i1}- Y_{i0}.$$\n", "\n", "This difference will then be defined as outcome in our DoubleMLData object. The data generating process make_did_SZ2020 already specifies the outcome y accordingly." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================== DoubleMLData Object ==================\n", "\n", "------------------ Data summary ------------------\n", "Outcome variable: y\n", "Treatment variable(s): ['d']\n", "Covariates: ['X1', 'X2', 'X3', 'X4']\n", "Instrument variable(s): None\n", "No. Observations: 1000\n", "\n", "------------------ DataFrame info ------------------\n", "\n", "RangeIndex: 1000 entries, 0 to 999\n", "Columns: 6 entries, X1 to d\n", "dtypes: float64(6)\n", "memory usage: 47.0 KB\n", "\n" ] } ], "source": [ "import numpy as np\n", "from doubleml.datasets import make_did_SZ2020\n", "from doubleml import DoubleMLData\n", "\n", "np.random.seed(42)\n", "n_obs = 1000\n", "x, y, d = make_did_SZ2020(n_obs=n_obs, dgp_type=4, cross_sectional_data=False, return_type='array')\n", "dml_data = DoubleMLData.from_arrays(x=x, y=y, d=d)\n", "print(dml_data)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### ATTE Estimation\n", "\n", "To estimate the ATTE with panel data, we will use the DoubleMLDID class. \n", "\n", "As for all DoubleML classes, we have to specify learners, which have to be initialized first.\n", "Here, we will just rely on a tree based method. \n", "\n", "The learner ml_g is used to fit conditional expectations of the outcome $\\mathbb{E}[\\Delta Y_i|D_i=0, X_i]$, whereas the learner ml_m will be used to estimate the propensity score $P(D_i=1|X_i)$." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from lightgbm import LGBMClassifier, LGBMRegressor\n", "\n", "n_estimators = 30\n", "ml_g = LGBMRegressor(n_estimators=n_estimators)\n", "ml_m = LGBMClassifier(n_estimators=n_estimators)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "The DoubleMLDID class can be used as any other DoubleML class. \n", "\n", "The score is set to score='observational', since the we generated data where the treatment probability depends on the pretreatment covariates. Further, we will use in_sample_normalization=True, since normalization generally improved the results in our simulations (both score='observational' and in_sample_normalization=True are default values).\n", "\n", "After initialization, we have to call the fit() method to estimate the nuisance elements." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "================== DoubleMLDID Object ==================\n", "\n", "------------------ Data summary ------------------\n", "Outcome variable: y\n", "Treatment variable(s): ['d']\n", "Covariates: ['X1', 'X2', 'X3', 'X4']\n", "Instrument variable(s): None\n", "No. Observations: 1000\n", "\n", "------------------ Score & algorithm ------------------\n", "Score function: observational\n", "DML algorithm: dml2\n", "\n", "------------------ Machine learner ------------------\n", "Learner ml_g: LGBMRegressor(n_estimators=30)\n", "Learner ml_m: LGBMClassifier(n_estimators=30)\n", "Out-of-sample Performance:\n", "Learner ml_g0 RMSE: [[11.43627032]]\n", "Learner ml_g1 RMSE: [[11.66989604]]\n", "Learner ml_m RMSE: [[0.48873663]]\n", "\n", "------------------ Resampling ------------------\n", "No. folds: 5\n", "No. repeated sample splits: 1\n", "Apply cross-fitting: True\n", "\n", "------------------ Fit summary ------------------\n", " coef std err t P>|t| 2.5 % 97.5 %\n", "d 1.386988 1.827375 0.759006 0.447849 -2.194601 4.968577\n" ] } ], "source": [ "from doubleml import DoubleMLDID\n", "dml_did = DoubleMLDID(dml_data, \n", " ml_g=ml_g, \n", " ml_m=ml_m,\n", " score='observational',\n", " in_sample_normalization=True,\n", " n_folds=5)\n", "\n", "dml_did.fit()\n", "print(dml_did)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "As usual, confidence intervals at different levels can be obtained via" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 5.0 % 95.0 %\n", "d -1.618776 4.392752\n" ] } ], "source": [ "print(dml_did.confint(level=0.90))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Coverage Simulation\n", "\n", "Here, we add a small coverage simulation to highlight the difference to the linear implementation of [Sant'Anna and Zhao (2020)](https://doi.org/10.1016/j.jeconom.2020.06.003). We generate multiple datasets, estimate the ATTE and collect the results (this may take some time). " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration: 0/200\n", "Iteration: 20/200\n", "Iteration: 40/200\n", "Iteration: 60/200\n", "Iteration: 80/200\n", "Iteration: 100/200\n", "Iteration: 120/200\n", "Iteration: 140/200\n", "Iteration: 160/200\n", "Iteration: 180/200\n" ] } ], "source": [ "n_rep = 200\n", "ATTE = 0.0\n", "\n", "ATTE_estimates = np.full((n_rep), np.nan)\n", "coverage = np.full((n_rep), np.nan)\n", "ci_length = np.full((n_rep), np.nan)\n", "\n", "np.random.seed(42)\n", "for i_rep in range(n_rep):\n", " if (i_rep % int(n_rep/10)) == 0:\n", " print(f'Iteration: {i_rep}/{n_rep}')\n", " dml_data = make_did_SZ2020(n_obs=n_obs, dgp_type=4, cross_sectional_data=False)\n", "\n", " dml_did = DoubleMLDID(dml_data, ml_g=ml_g, ml_m=ml_m, n_folds=5)\n", " dml_did.fit()\n", "\n", " ATTE_estimates[i_rep] = dml_did.coef.squeeze()\n", " confint = dml_did.confint(level=0.95)\n", " coverage [i_rep] = (confint['2.5 %'].iloc[0] <= ATTE) & (ATTE <= confint['97.5 %'].iloc[0])\n", " ci_length[i_rep] = confint['97.5 %'].iloc[0] - confint['2.5 %'].iloc[0]" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Let us take a look at the corresponding coverage and the length of the confidence intervals." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Coverage: 0.925\n", "Average CI length: 5.32236455588136\n" ] } ], "source": [ "print(f'Coverage: {coverage.mean()}')\n", "print(f'Average CI length: {ci_length.mean()}')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Here, we can observe that the coverage is still valid, since we did not rely on linear learners, so the setting is not misspecified in this example. \n", "\n", "If we know the conditional expectation is correctly specified (linear form), we can use this to obtain smaller confidence intervals but in many applications, we may want to safeguard against misspecification and use flexible models such as random forest or boosting.\n", "\n", "The distribution of the estimates takes the following form" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "