From 8c31f92a3087b77684c5b942312cce8b92cc224c Mon Sep 17 00:00:00 2001 From: Apoorva Lal Date: Wed, 21 Aug 2024 16:41:17 -0700 Subject: [PATCH] event studies with two-way-mundlak specification (#11) * query optimization + logging, mundlak event study wip * pandas compression * add multi-cohort * revise multi-cohort specification * add mundlak event study --- duckreg/duckreg.py | 26 +- duckreg/estimators.py | 267 +++++++++++- notebooks/event_study.ipynb | 828 ++++++++++++++++++++++++++++++++++++ 3 files changed, 1112 insertions(+), 9 deletions(-) create mode 100644 notebooks/event_study.ipynb diff --git a/duckreg/duckreg.py b/duckreg/duckreg.py index 54b4dd7..158a5a1 100644 --- a/duckreg/duckreg.py +++ b/duckreg/duckreg.py @@ -12,6 +12,7 @@ def __init__( seed: int, n_bootstraps: int = 100, fitter="numpy", + keep_connection_open=False, ): self.db_name = db_name self.table_name = table_name @@ -20,6 +21,7 @@ def __init__( self.conn = duckdb.connect(db_name) self.rng = np.random.default_rng(seed) self.fitter = fitter + self.keep_connection_open = keep_connection_open @abstractmethod def prepare_data(self): @@ -54,6 +56,7 @@ def fit(self): self.point_estimate = self.estimate() if self.n_bootstraps > 0: self.vcov = self.bootstrap() + self.conn.close() if not self.keep_connection_open else None return None elif self.fitter == "feols": fit = self.estimate_feols() @@ -64,6 +67,7 @@ def fit(self): fit.get_inference() fit._vcov_type = "NP-Bootstrap" fit._vcov_type_detail = "NP-Bootstrap" + self.conn.close() if not self.keep_connection_open else None return fit else: @@ -73,7 +77,12 @@ def fit(self): ) ) - def summary(self): + def summary(self) -> dict: + """Summary of regression + + Returns: + dict + """ if self.n_bootstraps > 0: return { "point_estimate": self.point_estimate, @@ -81,9 +90,22 @@ def summary(self): } return {"point_estimate": self.point_estimate} + def queries(self) -> dict: + """Collect all query methods in the class -def wls(X: np.ndarray, y: np.ndarray, n: np.ndarray) -> np.ndarray: + Returns: + dict: Dictionary of query methods + """ + self._query_names = [x for x in dir(self) if "query" in x] + self.queries = { + k: getattr(self, self._query_names[c]) + for c, k in enumerate(self._query_names) + } + return self.queries + +def wls(X: np.ndarray, y: np.ndarray, n: np.ndarray) -> np.ndarray: + """Weighted least squares with frequency weights""" N = np.sqrt(n) N = N.reshape(-1, 1) if N.ndim == 1 else N Xn = X * N diff --git a/duckreg/estimators.py b/duckreg/estimators.py index 5529acc..70167ac 100644 --- a/duckreg/estimators.py +++ b/duckreg/estimators.py @@ -18,8 +18,10 @@ def __init__( cluster_col: str, seed: int, n_bootstraps: int = 100, + event_study: bool = False, rowid_col: str = "rowid", fitter: str = "numpy", + **kwargs, ): super().__init__( db_name=db_name, @@ -27,6 +29,7 @@ def __init__( seed=seed, n_bootstraps=n_bootstraps, fitter=fitter, + **kwargs, ) self.formula = formula self.cluster_col = cluster_col @@ -34,7 +37,6 @@ def __init__( self._parse_formula() def _parse_formula(self): - lhs, rhs = self.formula.split("~") rhs_deparsed = rhs.split("|") covars, fevars = rhs.split("|") if len(rhs_deparsed) > 1 else (rhs, None) @@ -76,7 +78,6 @@ def compress_data(self): self.df_compressed.eval(create_means, inplace=True) def collect_data(self, data: pd.DataFrame) -> pd.DataFrame: - y = data.filter( regex=f"mean_{'(' + '|'.join(self.outcome_vars) + ')'}", axis=1 ).values @@ -124,7 +125,6 @@ def fit_vcov(self): self.vcov = n_nk * (bread @ meat @ bread) def estimate_feols(self): - if self.fevars: fml = f"{'+'.join([f'mean_{x}' for x in self.outcome_vars])} ~ {' + '.join(self.covars)} | {' + '.join(self.fevars)}" else: @@ -234,12 +234,14 @@ def __init__( time_col: str = None, n_bootstraps: int = 100, cluster_col: str = None, + **kwargs, ): super().__init__( db_name=db_name, table_name=table_name, seed=seed, n_bootstraps=n_bootstraps, + **kwargs, ) self.outcome_var = outcome_var self.covariates = covariates @@ -299,12 +301,12 @@ def compress_data(self): {', ' + ', '.join([f'avg_{cov}_time' for cov in self.covariates]) if self.time_col is not None else ''} """ self.df_compressed = self.conn.execute(self.compress_query).fetchdf() + self.df_compressed[f"mean_{self.outcome_var}"] = ( self.df_compressed[f"sum_{self.outcome_var}"] / self.df_compressed["count"] ) def collect_data(self, data: pd.DataFrame): - rhs = ( self.covariates + [f"avg_{cov}_unit" for cov in self.covariates] @@ -326,7 +328,6 @@ def collect_data(self, data: pd.DataFrame): return y, X, n def estimate(self): - y, X, n = self.collect_data(data=self.df_compressed) return wls(X, y, n) @@ -402,8 +403,259 @@ def bootstrap(self): ################################################################################ +class DuckMundlakEventStudy(DuckReg): + def __init__( + self, + db_name: str, + table_name: str, + outcome_var: str, + treatment_col: str, + unit_col: str, + time_col: str, + cluster_col: str, + n_bootstraps: int = 100, + **kwargs, + ): + super().__init__( + db_name=db_name, + table_name=table_name, + n_bootstraps=n_bootstraps, + **kwargs, + ) + self.table_name = table_name + self.outcome_var = outcome_var + self.treatment_col = treatment_col + self.unit_col = unit_col + self.time_col = time_col + self.num_periods = None + self.cohorts = None + self.time_dummies = None + self.post_treatment_dummies = None + self.transformed_query = None + self.compression_query = None + self.cluster_col = cluster_col + def prepare_data(self): + # create_cohort_and_ever_treated_columns + self.cohort_query = f""" + ALTER TABLE {self.table_name} ADD COLUMN cohort INTEGER; + UPDATE {self.table_name} SET cohort = ( + SELECT MIN({self.time_col}) + FROM {self.table_name} AS p2 + WHERE p2.{self.unit_col} = {self.table_name}.{self.unit_col} AND p2.{self.treatment_col} = 1 + ); + """ + self.conn.execute(self.cohort_query) + self.ever_treated_query = f""" + UPDATE {self.table_name} SET cohort = NULL WHERE cohort = 2147483647; -- Set to NULL if never treated + ALTER TABLE {self.table_name} ADD COLUMN ever_treated INTEGER; + UPDATE {self.table_name} SET ever_treated = CASE WHEN cohort IS NOT NULL THEN 1 ELSE 0 END; + """ + self.conn.execute(self.ever_treated_query) + # retrieve_num_periods_and_cohorts + self.num_periods = self.conn.execute( + f"SELECT MAX({self.time_col}) FROM {self.table_name}" + ).fetchone()[0] + cohorts = self.conn.execute( + f"SELECT DISTINCT cohort FROM {self.table_name} WHERE cohort IS NOT NULL" + ).fetchall() + self.cohorts = [row[0] for row in cohorts] + # generate_time_dummies + self.time_dummies = ",\n".join( + [ + f"CASE WHEN {self.time_col} = {i} THEN 1 ELSE 0 END AS time_{i}" + for i in range(self.num_periods + 1) + ] + ) + # generate cohort dummies + cohort_intercepts = [] + for cohort in self.cohorts: + cohort_intercepts.append( + f"CASE WHEN cohort = {cohort} THEN 1 ELSE 0 END AS cohort_{cohort}" + ) + self.cohort_intercepts = ",\n".join(cohort_intercepts) + + # generate_treatment_dummies + treatment_dummies = [] + for cohort in self.cohorts: + for i in range(self.num_periods + 1): + treatment_dummies.append( + f"CASE WHEN cohort = {cohort} AND {self.time_col} = {i} THEN 1 ELSE 0 END AS treatment_time_{cohort}_{i}" + ) + self.treatment_dummies = ",\n".join(treatment_dummies) + # create_transformed_query + self.design_matrix_query = f""" + CREATE TEMP TABLE transformed_panel_data AS + SELECT + p.{self.unit_col}, + p.{self.time_col}, + p.{self.treatment_col}, + p.{self.outcome_var}, + -- Intercept (constant term) + 1 AS intercept, + -- cohort intercepts + {self.cohort_intercepts}, + -- Time dummies for each period + {self.time_dummies}, + -- Treated group interacted with treatment time dummies + {self.treatment_dummies} + FROM + {self.table_name} p; + """ + self.conn.execute(self.design_matrix_query) + + def compress_data(self): + self.rhs = f""" + intercept, + {", ".join([f"cohort_{cohort}" for cohort in self.cohorts])}, + {", ".join([f"time_{i}" for i in range(self.num_periods + 1)])}, + {", ".join([f"treatment_time_{cohort}_{i}" for cohort in self.cohorts for i in range(self.num_periods + 1)])}; + """ + self.compression_query = f""" + CREATE TEMP TABLE compressed_panel_data AS + SELECT + {self.rhs.replace(";", "")}, + COUNT(*) AS count, + SUM({self.outcome_var}) AS sum_{self.outcome_var} + FROM + transformed_panel_data + GROUP BY + {self.rhs} + """ + self.conn.execute(self.compression_query) + self.df_compressed = self.conn.execute( + "SELECT * FROM compressed_panel_data" + ).fetchdf() + self.df_compressed[f"mean_{self.outcome_var}"] = ( + self.df_compressed[f"sum_{self.outcome_var}"] / self.df_compressed["count"] + ) + + def collect_data(self, data): + self._rhs_list = [x.strip().replace(";", "") for x in self.rhs.split(",")] + X = data[self._rhs_list].values + y = data[f"mean_{self.outcome_var}"].values + n = data["count"].values + + y = y.reshape(-1, 1) if y.ndim == 1 else y + X = X.reshape(-1, 1) if X.ndim == 1 else X + return y, X, n + + def estimate(self): + y, X, n = self.collect_data(data=self.df_compressed) + coef = wls(X, y, n) + res = pd.DataFrame( + { + "est": coef.squeeze(), + }, + index=self._rhs_list, + ) + cohort_names = [x.split("_")[1] for x in self._rhs_list if "cohort_" in x] + event_study_coefs = {} + for c in cohort_names: + offset = res.filter(regex=f"^cohort_{c}", axis=0).values + event_study_coefs[c] = ( + res.filter(regex=f"treatment_time_{c}_", axis=0) + offset + ) + + return event_study_coefs + + def bootstrap(self): + # list all clusters + total_clusters = self.conn.execute( + f"SELECT COUNT(DISTINCT {self.cluster_col}) FROM transformed_panel_data" + ).fetchone()[0] + boot_coefs = {str(cohort): [] for cohort in self.cohorts} + # bootstrap loop + for _ in tqdm(range(self.n_bootstraps)): + resampled_clusters = ( + self.conn.execute( + f"SELECT UNNEST(ARRAY(SELECT {self.cluster_col} FROM transformed_panel_data ORDER BY RANDOM() LIMIT {total_clusters}))" + ) + .fetchdf() + .values.flatten() + .tolist() + ) + + self.conn.execute( + f""" + CREATE TEMP TABLE resampled_transformed_panel_data AS + SELECT * FROM transformed_panel_data + WHERE {self.cluster_col} IN ({', '.join(map(str, resampled_clusters))}) + """ + ) + + self.conn.execute( + f""" + CREATE TEMP TABLE resampled_compressed_panel_data AS + SELECT + {self.rhs.replace(";", "")}, + COUNT(*) AS count, + SUM({self.outcome_var}) AS sum_{self.outcome_var} + FROM + resampled_transformed_panel_data + GROUP BY + {self.rhs.replace(";", "")} + """ + ) + + df_boot = self.conn.execute( + "SELECT * FROM resampled_compressed_panel_data" + ).fetchdf() + df_boot[f"mean_{self.outcome_var}"] = ( + df_boot[f"sum_{self.outcome_var}"] / df_boot["count"] + ) + + y, X, n = self.collect_data(data=df_boot) + coef = wls(X, y, n) + res = pd.DataFrame( + { + "est": coef.squeeze(), + }, + index=self._rhs_list, + ) + cohort_names = [x.split("_")[1] for x in self._rhs_list if "cohort_" in x] + for c in cohort_names: + offset = res.filter(regex=f"^cohort_{c}", axis=0).values + event_study_coefs = ( + res.filter(regex=f"treatment_time_{c}_", axis=0) + offset + ) + boot_coefs[c].append(event_study_coefs.values.flatten()) + + self.conn.execute("DROP TABLE resampled_transformed_panel_data") + self.conn.execute("DROP TABLE resampled_compressed_panel_data") + # Calculate the covariance matrix for each cohort + bootstrap_cov_matrix = { + cohort: np.cov(np.array(coefs).T) for cohort, coefs in boot_coefs.items() + } + return bootstrap_cov_matrix + + def estimate_feols(self): + raise NotImplementedError( + "feols solver not implemented for Mundlak event study estimator" + ) + + def summary(self) -> dict: + """Summary of event study regression (overrides the parent class method) + + Returns: + dict of event study coefficients and their standard errors + """ + if self.n_bootstraps > 0: + summary_tables = {} + for c in self.point_estimate.keys(): + point_estimate = self.point_estimate[c] + se = np.sqrt(np.diag(self.vcov[c])) + summary_tables[c] = pd.DataFrame( + np.c_[point_estimate, se], + columns=["point_estimate", "se"], + index=point_estimate.index, + ) + return summary_tables + return {"point_estimate": self.point_estimate} + + +################################################################################ class DuckDoubleDemeaning(DuckReg): def __init__( self, @@ -416,12 +668,14 @@ def __init__( seed: int, n_bootstraps: int = 100, cluster_col: str = None, + **kwargs, ): super().__init__( db_name=db_name, table_name=table_name, seed=seed, n_bootstraps=n_bootstraps, + **kwargs, ) self.outcome_var = outcome_var self.treatment_var = treatment_var @@ -486,7 +740,6 @@ def compress_data(self): ) def collect_data(self, data: pd.DataFrame): - X = data[f"ddot_{self.treatment_var}"].values X = np.c_[np.ones(X.shape[0]), X] y = data[f"mean_{self.outcome_var}"].values @@ -558,4 +811,4 @@ def bootstrap(self): return np.cov(boot_coefs.T) -###################################################################### +################################################################################ diff --git a/notebooks/event_study.ipynb b/notebooks/event_study.ipynb new file mode 100644 index 0000000..6166df5 --- /dev/null +++ b/notebooks/event_study.ipynb @@ -0,0 +1,828 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# `duckreg` for panel data: Applying Mundlak Regression to estimate Event Studies at scale" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from duckreg.estimators import DuckMundlak, DuckMundlakEventStudy\n", + "import duckdb\n", + "import pyfixest as pf\n", + "\n", + "np.random.seed(42)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def panel_dgp(\n", + " num_units=1000,\n", + " num_periods=30,\n", + " num_treated=50,\n", + " treatment_start=15,\n", + " hetfx=False,\n", + " base_treatment_effect=np.repeat(0, 15),\n", + " ar_coef=0.2, # Autoregressive coefficient for epsilon_it\n", + " sigma_unit=1,\n", + " sigma_time=0.5,\n", + " sigma_epsilon=0.5, # Standard deviation of epsilon_it\n", + "):\n", + " unit_intercepts = np.random.normal(0, sigma_unit, num_units)\n", + "\n", + " # Generate day-of-the-week pattern\n", + " day_effects = np.array(\n", + " [-0.1, 0.1, 0, 0, 0.1, 0.5, 0.5]\n", + " ) # Stronger effects on weekends\n", + " day_pattern = np.tile(day_effects, num_periods // 7 + 1)[:num_periods]\n", + "\n", + " # Generate autoregressive structure\n", + " ar_coef_time = 0.2\n", + " ar_noise_time = np.random.normal(0, sigma_time, num_periods)\n", + " time_intercepts = np.zeros(num_periods)\n", + " time_intercepts[0] = ar_noise_time[0]\n", + " for t in range(1, num_periods):\n", + " time_intercepts[t] = ar_coef_time * time_intercepts[t - 1] + ar_noise_time[t]\n", + " # Combine day-of-the-week pattern and autoregressive structure\n", + " time_intercepts = day_pattern + time_intercepts - np.mean(time_intercepts)\n", + " # Generate autoregressive noise for each unit\n", + " ar_noise = np.random.normal(0, sigma_epsilon, (num_units, num_periods))\n", + " noise = np.zeros((num_units, num_periods))\n", + " noise[:, 0] = ar_noise[:, 0]\n", + " for t in range(1, num_periods):\n", + " noise[:, t] = ar_coef * noise[:, t - 1] + ar_noise[:, t]\n", + " # N X T matrix of potential outcomes under control\n", + " Y0 = unit_intercepts[:, np.newaxis] + time_intercepts[np.newaxis, :] + noise\n", + " # Generate the base treatment effect (concave structure)\n", + " # Generate heterogeneous multipliers for each unit\n", + " if hetfx:\n", + " heterogeneous_multipliers = np.random.uniform(0.5, 1.5, num_units)\n", + " else:\n", + " heterogeneous_multipliers = np.ones(num_units)\n", + "\n", + " # Create a 2D array to store the heterogeneous treatment effects\n", + " treatment_effect = np.zeros((num_units, num_periods - treatment_start))\n", + " for i in range(num_units):\n", + " treatment_effect[i, :] = heterogeneous_multipliers[i] * base_treatment_effect\n", + "\n", + " # random assignment\n", + " treated_units = np.random.choice(num_units, num_treated, replace=False)\n", + " treatment_status = np.zeros((num_units, num_periods), dtype=bool)\n", + " treatment_status[treated_units, treatment_start:] = True\n", + "\n", + " # Apply the heterogeneous treatment effect to the treated units\n", + " Y1 = Y0.copy()\n", + " for t in range(treatment_start, num_periods):\n", + " Y1[:, t][treatment_status[:, t]] += treatment_effect[:, t - treatment_start][\n", + " treatment_status[:, t]\n", + " ]\n", + "\n", + " # Create a DataFrame\n", + " unit_ids = np.repeat(np.arange(num_units), num_periods)\n", + " time_ids = np.tile(np.arange(num_periods), num_units)\n", + " W_it = treatment_status.flatten()\n", + " Y_it = np.where(W_it, Y1.flatten(), Y0.flatten())\n", + " df = pd.DataFrame(\n", + " {\n", + " \"unit_id\": unit_ids,\n", + " \"time_id\": time_ids,\n", + " \"W_it\": W_it.astype(int),\n", + " \"Y_it\": Y_it,\n", + " }\n", + " )\n", + " return df\n", + "\n", + "\n", + "# Function to create and populate DuckDB database\n", + "def create_duckdb_database(df, db_name=\"large_dataset.db\", table=\"panel_data\"):\n", + " conn = duckdb.connect(db_name)\n", + " conn.execute(f\"DROP TABLE IF EXISTS {table}\")\n", + " conn.execute(f\"CREATE TABLE {table} AS SELECT * FROM df\")\n", + " conn.close()\n", + " print(f\"Data loaded into DuckDB database: {db_name}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "num_periods = 30\n", + "treat_start_period = 15\n", + "treat_effect_vector= 0.2 * np.log(2 * np.arange(1, num_periods - treat_start_period + 1))\n", + "treat_effect_vector[8:] = 0 # switch off effects after a week\n", + "sigma_i, sigma_t = 2, 1\n", + "event_study_true = np.r_[np.repeat(0, num_periods-treat_start_period), treat_effect_vector]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data loaded into DuckDB database: event_study_data.db\n" + ] + } + ], + "source": [ + "df = panel_dgp(\n", + " num_units=10_000, num_treated= 5_000,\n", + " num_periods=30,\n", + " treatment_start = treat_start_period,\n", + " hetfx=False,\n", + " base_treatment_effect = treat_effect_vector,\n", + " sigma_unit = sigma_i, sigma_time = sigma_t,\n", + ")\n", + "\n", + "db_name = 'event_study_data.db'\n", + "create_duckdb_database(df, db_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
unit_idtime_idW_itY_it
00000.436139
10101.016883
20200.480516
30300.578209
40401.066747
\n", + "
" + ], + "text/plain": [ + " unit_id time_id W_it Y_it\n", + "0 0 0 0 0.436139\n", + "1 0 1 0 1.016883\n", + "2 0 2 0 0.480516\n", + "3 0 3 0 0.578209\n", + "4 0 4 0 1.066747" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Static Specification\n", + "\n", + "### Two-way Mundlak" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:01<00:00, 65.08it/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "point_estimate 0.203918\n", + "standard_error 0.003637\n", + "Name: 1, dtype: float64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mundlak = DuckMundlak(\n", + " db_name=\"event_study_data.db\",\n", + " table_name=\"panel_data\",\n", + " outcome_var=\"Y_it\",\n", + " covariates=[\"W_it\"],\n", + " unit_col=\"unit_id\",\n", + " time_col=\"time_id\",\n", + " cluster_col=\"unit_id\",\n", + " n_bootstraps=100,\n", + " seed = 42\n", + ")\n", + "mundlak.fit()\n", + "\n", + "mundlak_results = mundlak.summary()\n", + "\n", + "restab = pd.DataFrame(\n", + " np.c_[mundlak_results[\"point_estimate\"], mundlak_results[\"standard_error\"]],\n", + " columns=[\"point_estimate\", \"standard_error\"],\n", + ").iloc[1, :]\n", + "restab" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.21533040462966416" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "treat_effect_vector.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Two-way Mundlak specification consistently recovers the average treatment effect in the post-treatment period. Under staggered adoption, however, this guarantee is lost. More on this later. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dynamic Specification\n", + "\n", + "### Single Treatment Cohort" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "df[\"ever_treated\"] = df.groupby(\"unit_id\")[\"W_it\"].transform(\"max\")\n", + "m2 = pf.feols(\"\"\"\n", + " Y_it ~ i(time_id, ever_treated, ref = 14) |\n", + " unit_id + time_id\n", + " \"\"\",\n", + " df\n", + " )\n", + "evstudy_coefs = m2.coef().values\n", + "# insert zero in reference period\n", + "evstudy_coefs = np.insert(evstudy_coefs, 14, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### compressed estimation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " unit_id time_id W_it Y_it\n", + "0 0 0 0 0.436139\n", + "1 0 1 0 1.016883\n", + "2 0 2 0 0.480516\n", + "3 0 3 0 0.578209\n", + "4 0 4 0 1.066747\n" + ] + } + ], + "source": [ + "conn = duckdb.connect(\"event_study_data.db\")\n", + "print(conn.execute(\"SELECT * FROM panel_data LIMIT 5\").fetchdf())\n", + "conn.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "mundlak = DuckMundlakEventStudy(\n", + " db_name=\"event_study_data.db\",\n", + " table_name=\"panel_data\",\n", + " outcome_var=\"Y_it\",\n", + " treatment_col=\"W_it\",\n", + " unit_col=\"unit_id\",\n", + " time_col=\"time_id\",\n", + " cluster_col=\"unit_id\",\n", + " n_bootstraps=0, # set to nonzero to get block-bootstrapped standard errors\n", + " seed=42,\n", + ")\n", + "\n", + "mundlak.fit()\n", + "evsum = mundlak.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mundlak_estimates = evsum[\"point_estimate\"][\"15\"]\n", + "time_labels = [\n", + " int(x.replace(\"treatment_time_15_\", \"\")) for x in mundlak_estimates.index\n", + "]\n", + "f, ax = plt.subplots(1, 1, figsize=(10, 6))\n", + "ax.plot(event_study_true, marker=\".\", label=\"True Treatment Effect\")\n", + "ax.plot(time_labels, mundlak_estimates, marker=\".\", label=\"Mundlak Estimate\")\n", + "ax.plot(time_labels, evstudy_coefs, marker=\".\", label=\"2WFE estimate\")\n", + "ax.axvline(14.5, color=\"red\", linestyle=\"--\")\n", + "ax.axhline(0, color=\"red\", linestyle=\"--\")\n", + "ax.set_ylabel(\"Dynamic Treatment Effect\")\n", + "ax.set_xlabel(\"Time\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The two-way Mundlak specification correctly recovers the treatment effect/impulse response function." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multiple cohorts\n", + "\n", + "Event study, followed by fully interacted (Sunab / Wooldridge) regression." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def panel_dgp_stagg(\n", + " num_units=100,\n", + " num_periods=30,\n", + " num_treated=[50],\n", + " treatment_start_cohorts=[15],\n", + " sigma_unit=1,\n", + " sigma_time=0.5,\n", + " sigma_epsilon=0.2,\n", + " hetfx=False,\n", + " base_treatment_effects=[0.1 * np.log(np.arange(1, 30 - 15 + 1))],\n", + " return_dataframe=True,\n", + " ar_coef=0.8,\n", + "):\n", + " # unit FEs\n", + " unit_intercepts = np.random.normal(0, sigma_unit, num_units)\n", + " ####################################################################\n", + " # time FEs: Generate day-of-the-week pattern\n", + " day_effects = np.array(\n", + " [-0.1, 0.1, 0, 0, 0.1, 0.5, 0.5]\n", + " ) # Stronger effects on weekends\n", + " day_pattern = np.tile(day_effects, num_periods // 7 + 1)[:num_periods]\n", + " # autoregressive structure in time FEs\n", + " ar_coef_time = 0.2\n", + " ar_noise_time = np.random.normal(0, sigma_time, num_periods)\n", + " time_intercepts = np.zeros(num_periods)\n", + " time_intercepts[0] = ar_noise_time[0]\n", + " for t in range(1, num_periods):\n", + " time_intercepts[t] = ar_coef_time * time_intercepts[t - 1] + ar_noise_time[t]\n", + " # Combine day-of-the-week pattern and autoregressive structure\n", + " time_intercepts = day_pattern + time_intercepts - np.mean(time_intercepts)\n", + " ####################################################################\n", + " # Generate autoregressive noise for each unit\n", + " ar_noise = np.random.normal(0, sigma_epsilon, (num_units, num_periods))\n", + " noise = np.zeros((num_units, num_periods))\n", + " noise[:, 0] = ar_noise[:, 0]\n", + " for t in range(1, num_periods):\n", + " noise[:, t] = ar_coef * noise[:, t - 1] + ar_noise[:, t]\n", + " # N X T matrix of potential outcomes under control\n", + " Y0 = unit_intercepts[:, np.newaxis] + time_intercepts[np.newaxis, :] + noise\n", + " ####################################################################\n", + " # Generate heterogeneous multipliers for each unit\n", + " if hetfx:\n", + " heterogeneous_multipliers = np.random.uniform(0.5, 1.5, num_units)\n", + " else:\n", + " heterogeneous_multipliers = np.ones(num_units)\n", + " # random assignment\n", + " treated_units = np.array([], dtype=int)\n", + " treatment_status = np.zeros((num_units, num_periods), dtype=bool)\n", + " ####################################################################\n", + " # Create a 2D array to store the heterogeneous treatment effects\n", + " treatment_effect = np.zeros((num_units, num_periods))\n", + " # iterate over treatment cohorts\n", + " for cohort_idx, (treatment_start, num_treated_cohort) in enumerate(\n", + " zip(treatment_start_cohorts, num_treated)\n", + " ):\n", + " base_treatment_effect = base_treatment_effects[cohort_idx]\n", + " cohort_treatment_effect = np.zeros((num_units, num_periods - treatment_start))\n", + "\n", + " for i in range(num_units):\n", + " cohort_treatment_effect[i, :] = (\n", + " heterogeneous_multipliers[i] * base_treatment_effect\n", + " )\n", + " cohort_treated_units = np.random.choice(\n", + " np.setdiff1d(np.arange(num_units), treated_units),\n", + " num_treated_cohort,\n", + " replace=False,\n", + " )\n", + " treated_units = np.concatenate((treated_units, cohort_treated_units))\n", + " treatment_status[cohort_treated_units, treatment_start:] = True\n", + " treatment_effect[\n", + " cohort_treated_units, treatment_start:\n", + " ] += cohort_treatment_effect[cohort_treated_units, :]\n", + "\n", + " # Apply the heterogeneous treatment effect to the treated units\n", + " Y1 = Y0.copy()\n", + " Y1[treatment_status] += treatment_effect[treatment_status]\n", + " ####################################################################\n", + " result = {\n", + " \"Y1\": Y1,\n", + " \"Y0\": Y0,\n", + " \"W\": treatment_status,\n", + " \"unit_intercepts\": unit_intercepts,\n", + " \"time_intercepts\": time_intercepts,\n", + " }\n", + "\n", + " if return_dataframe:\n", + " # Create a DataFrame\n", + " unit_ids = np.repeat(np.arange(num_units), num_periods)\n", + " time_ids = np.tile(np.arange(num_periods), num_units)\n", + " W_it = treatment_status.flatten().astype(int)\n", + " Y_it = np.where(W_it, Y1.flatten(), Y0.flatten())\n", + " unit_intercepts_flat = np.repeat(unit_intercepts, num_periods)\n", + " time_intercepts_flat = np.tile(time_intercepts, num_units)\n", + " df = pd.DataFrame(\n", + " {\n", + " \"unit_id\": unit_ids,\n", + " \"time_id\": time_ids,\n", + " \"W_it\": W_it,\n", + " \"Y_it\": Y_it,\n", + " \"unit_intercept\": unit_intercepts_flat,\n", + " \"time_intercept\": time_intercepts_flat,\n", + " }\n", + " )\n", + " result[\"dataframe\"] = df\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Effect functions:\n", + "+ Cohort 1: mean reversal: big bump that decays to zero within 10 days, then zero\n", + "+ Cohort 2: shark-fin - logarithmic for the first week, then 0\n", + "+ Cohort 3: sinusoidal " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "num_periods = 30\n", + "treatment_start_cohorts = [10, 15, 20]\n", + "num_treated_units = [25_000, 50_000, 25_000]\n", + "\n", + "# effect functions\n", + "treat_effect_vector_1 = np.log(2 * np.arange(1, num_periods - treatment_start_cohorts[1]+ 1))\n", + "treat_effect_vector_1[8:] = 0 # switch off effects after a week\n", + "base_treatment_effects = [\n", + " np.r_[np.linspace(2, 0, num_periods - treatment_start_cohorts[0] - 10), np.repeat(0, 10)],\n", + " treat_effect_vector_1,\n", + " np.sin(np.arange(1, num_periods - treatment_start_cohorts[2] + 1)) # Treatment effect function for cohort 2\n", + "]\n", + "\n", + "sigma_i, sigma_t = 2, 1\n", + "sigma_epsilon=1\n", + "dgp = panel_dgp_stagg(\n", + " num_units=100_000, num_treated=num_treated_units,\n", + " num_periods=num_periods,\n", + " treatment_start_cohorts = treatment_start_cohorts, hetfx=False,\n", + " base_treatment_effects= base_treatment_effects,\n", + " sigma_unit = sigma_i, sigma_time = sigma_t,\n", + " sigma_epsilon=sigma_epsilon,\n", + ")\n", + "Y0, Y1, W, df = dgp[\"Y0\"], dgp[\"Y1\"], dgp[\"W\"], dgp[\"dataframe\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data loaded into DuckDB database: stagg_event_study_data.db\n" + ] + } + ], + "source": [ + "db_name = 'stagg_event_study_data.db'\n", + "create_duckdb_database(df, db_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "410c12b21e7243ecafa900b94470cd10", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, layout=Layout(width='auto'), style=ProgressStyle(bar_color='black'))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mundlak = DuckMundlakEventStudy(\n", + " db_name=\"stagg_event_study_data.db\",\n", + " table_name=\"panel_data\",\n", + " outcome_var=\"Y_it\",\n", + " treatment_col=\"W_it\",\n", + " unit_col=\"unit_id\",\n", + " time_col=\"time_id\",\n", + " cluster_col=\"unit_id\",\n", + " n_bootstraps=0,\n", + " seed=42,\n", + ")\n", + "\n", + "mundlak.fit()\n", + "evsum = mundlak.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure and axis\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "\n", + "for cohort_start in treatment_start_cohorts:\n", + " ax.axvline(x=cohort_start - 0.5, color='red', linestyle='--')\n", + "# Plot the true treatment effect functions for each cohort\n", + "for cohort_idx, cohort_start in enumerate(treatment_start_cohorts):\n", + " effect_vector = base_treatment_effects[cohort_idx]\n", + " effect_vector_padded = np.zeros(num_periods)\n", + " effect_vector_padded[cohort_start:cohort_start+len(effect_vector)] = effect_vector\n", + " ax.plot(effect_vector_padded, marker=\".\", label=f\"True Effect (Cohort {cohort_idx + 1})\")\n", + " # estimated cohort effect\n", + " cohort_estimates = evsum[\"point_estimate\"][f\"{cohort_start}\"].values\n", + " ax.plot(cohort_estimates, marker=\"o\", label=f\"Estimated Effect (Cohort {cohort_idx + 1})\")\n", + "\n", + "# Overlay week dotted lines\n", + "for week in range(1, num_periods // 7 + 1):\n", + " ax.axvline(x=week * 7 - 0.5, color='k', linestyle=':', alpha=0.5)\n", + "\n", + "# Add labels and title\n", + "ax.set_xlabel(\"Time\")\n", + "ax.set_title(\"Event Study estimates under staggered adoption\")\n", + "# Add legend\n", + "ax.legend()\n", + "# Show the plot\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, we get the correct treatment effect/impulse response function for each cohort. Estimates are considerably noisier, however." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "econometrics", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}