Continuous Difference-in-Differences#

Continuous DiD estimator for dose-response curves with continuous treatment intensity.

This module implements the methodology from Callaway, Goodman-Bacon & Sant’Anna (2024), “Difference-in-Differences with a Continuous Treatment” (NBER WP 32117), which:

Estimates dose-response curves: ATT(d) and ACRT(d) as functions of dose
Computes summary parameters: Overall ATT (binarized) and ACRT aggregated across doses
Uses B-spline smoothing: Flexible nonparametric estimation of dose-response functions
Supports multiplier bootstrap: Valid inference with proper standard errors and CIs

Note

Identification assumptions. The dose-response curves ATT(d) and ACRT(d), as well as ATT^glob and ACRT^glob, require the Strong Parallel Trends (SPT) assumption — that there is no selection into dose groups based on treatment effects. Under the weaker standard Parallel Trends (PT) assumption, only the binarized ATT^loc (overall_att) is identified; it equals ATT^glob only when SPT holds. See Callaway, Goodman-Bacon & Sant’Anna (2024), Assumptions 1–2.

When to use Continuous DiD:

Treatment varies in intensity or dose across units (not just binary on/off)
You want to estimate how effects change with treatment dose
Staggered adoption with heterogeneous dose levels
You need the full dose-response curve, not just a single average effect

Data requirements:

An untreated group (D = 0) must be present in the data
A balanced panel is required (all units observed in all time periods)
Dose must be time-invariant — each unit’s dose is fixed across periods

Reference: Callaway, B., Goodman-Bacon, A., & Sant’Anna, P. H. C. (2024). Difference-in-Differences with a Continuous Treatment. NBER Working Paper 32117. https://www.nber.org/papers/w32117

ContinuousDiD#

Main estimator class for Continuous Difference-in-Differences.

class diff_diff.ContinuousDiD[source]

Bases: object

Continuous Difference-in-Differences estimator.

Implements the methodology from Callaway, Goodman-Bacon & Sant’Anna (2024) for estimating dose-response curves when treatment has a continuous intensity.

Parameters:

degree (int, default=3) – B-spline degree (3 = cubic).
num_knots (int, default=0) – Number of interior knots for the B-spline basis.
dvals (array-like, optional) – Custom dose evaluation grid. If None, uses quantile-based default.
control_group (str, default="never_treated") – "never_treated", "not_yet_treated", or "lowest_dose". "lowest_dose" implements Remark 3.1 (CGBS 2024) for settings with no never-treated / zero-dose units (P(D=0) = 0): the lowest-dose group d_L becomes the comparison and the estimand is ATT(d) − ATT(d_L). Requires a genuine lowest-dose group (>= 2 units at d_L, i.e. P(D=d_L) > 0) and no never-treated units present. Single-cohort only (multi-cohort and covariates= raise NotImplementedError).
anticipation (int, default=0) – Number of periods of treatment anticipation.
base_period (str, default="varying") – "varying" or "universal".
alpha (float, default=0.05) – Significance level for confidence intervals.
n_bootstrap (int, default=0) – Number of multiplier bootstrap iterations. 0 for analytical SEs only.
bootstrap_weights (str, default="rademacher") – Bootstrap weight type: "rademacher", "mammen", or "webb".
seed (int, optional) – Random seed for reproducibility.
rank_deficient_action (str, default="warn") – Action for rank-deficient B-spline OLS: "warn", "error", or "silent".
covariates (list of str, optional) – Column names of covariates for conditional parallel trends (E[ΔY(0) | D=d, X] = E[ΔY(0) | D=0, X]). When None (default) the estimator uses unconditional parallel trends. Covariates enter through a covariate-adjusted per-cell control counterfactual (see estimation_method). Covariates are read from the base period of each (g, t) comparison. Not currently composable with survey_design= (raises NotImplementedError).
estimation_method (str, default="dr") – Covariate-adjustment method (only used when covariates is set): "reg" (outcome regression) or "dr" (doubly-robust, the default). "ipw" is not supported on the dose / event-study aggregation — pure IPW’s covariate adjustment is a single scalar level shift, so it cannot adjust the dose-response shape (ACRT(d) would be identical to the unconditional fit); it raises NotImplementedError. reg and dr share the dose-response shape and ACRT(d); dr differs only in the overall_att / ATT(d) level and in its doubly-robust standard errors.
pscore_trim (float, default=0.01) – Propensity-score trimming bound for the dr path (scores clipped to [pscore_trim, 1 - pscore_trim]).
epv_threshold (float, default=10.0) – Events-per-variable threshold for the dr propensity logit diagnostics.
pscore_fallback (str, default="error") – Action when dr propensity estimation raises (the logit IRLS fails with a LinAlgError / ValueError, e.g. perfect separation or rank deficiency): "error" (re-raise — the default, fail-closed so a dr fit never silently degrades to a non-DR estimate) or "unconditional" (fall back to an unconditional propensity with a warning; the affected cells are then reg-like — use only when you knowingly accept that). Note: low events-per-variable emits a diagnostic warning but does not itself trigger the fallback.
treatment_type (str, default="continuous") – Dose-response model: "continuous" (B-spline sieve, the default) or "discrete" (saturated per-dose-level regression, CGBS 2024 Eq. 4.1). On the discrete path each distinct dose level gets its own effect coefficient — ATT(d_j) = mean_{D=d_j}(ΔY) − control (a per-level 2×2 DiD) — and ACRT(d_j) is the paper’s backward finite difference on the grid {0, d_1, ..., d_J} (ACRT(d_1) = ATT(d_1)/d_1, so a binary dose D in {0, 1} gives ACRT = ATT). It composes with covariates and survey_design and reduces to the per-level 2×2 DiD standard error. Multi-cohort fits must share the same dose support across cohorts (else NotImplementedError); an off-support dvals value raises ValueError.

Examples

>>> from diff_diff import ContinuousDiD, generate_continuous_did_data
>>> data = generate_continuous_did_data(n_units=200, seed=42)
>>> est = ContinuousDiD(n_bootstrap=199, seed=42)
>>> results = est.fit(data, outcome="outcome", unit="unit",
...                   time="period", first_treat="first_treat",
...                   dose="dose", aggregate="dose")
>>> results.overall_att

Methods

`fit`(data, outcome, unit, time, first_treat, dose)	Fit the continuous DiD estimator.
`get_params`()	Return estimator parameters as a dictionary.
`set_params`(**params)	Set estimator parameters and return self.

__init__(degree=3, num_knots=0, dvals=None, control_group='never_treated', anticipation=0, base_period='varying', alpha=0.05, n_bootstrap=0, bootstrap_weights='rademacher', seed=None, rank_deficient_action='warn', covariates=None, estimation_method='dr', pscore_trim=0.01, epv_threshold=10.0, pscore_fallback='error', treatment_type='continuous')[source]

Parameters:

degree (int)
num_knots (int)
dvals (ndarray | None)
control_group (str)
anticipation (int)
base_period (str)
alpha (float)
n_bootstrap (int)
bootstrap_weights (str)
seed (int | None)
rank_deficient_action (str)
covariates (List[str] | None)
estimation_method (str)
pscore_trim (float)
epv_threshold (float)
pscore_fallback (str)
treatment_type (str)

get_params()[source]

Return estimator parameters as a dictionary.

Return type:: Dict[str, Any]

set_params(**params)[source]

Set estimator parameters and return self.

Transactional: the candidate configuration is validated against a clone before any attribute on self is mutated, so an invalid update leaves the estimator unchanged (no half-applied state).

Return type:: ContinuousDiD

fit(data, outcome, unit, time, first_treat, dose, aggregate=None, survey_design=None)[source]

Fit the continuous DiD estimator.

Parameters:

data (pd.DataFrame) – Panel data.
outcome (str) – Outcome column name.
unit (str) – Unit identifier column.
time (str) – Time period column.
first_treat (str) – First treatment period column (0 or inf for never-treated).
dose (str) – Continuous dose column.
aggregate (str, optional) – "dose" for dose-response aggregation, "eventstudy" for binarized event study.
survey_design (SurveyDesign, optional) – Survey design specification for design-based inference. Supports weighted estimation and Taylor series linearization variance with strata, PSU, and FPC.

Return type:

ContinuousDiDResults

ContinuousDiDResults#

Results container for Continuous DiD estimation.

class diff_diff.continuous_did_results.ContinuousDiDResults[source]

Bases: BaseResults

Results from Continuous Difference-in-Differences estimation.

Implements Callaway, Goodman-Bacon & Sant’Anna (2024).

dose_response_att

ATT(d) dose-response curve.

Type:: DoseResponseCurve

dose_response_acrt

ACRT(d) dose-response curve.

Type:: DoseResponseCurve

overall_att

Binarized overall ATT (ATT^{loc} under PT, equals ATT^{glob} under SPT).

Type:: float

overall_acrt

Plug-in overall ACRT^{glob}.

Type:: float

group_time_effects

Per (g,t) cell results.

Type:: dict

base_period

Base period strategy ("varying" or "universal").

Type:: str

anticipation

Number of anticipation periods.

Type:: int

n_bootstrap

Number of bootstrap iterations used.

Type:: int

bootstrap_weights

Bootstrap weight type ("rademacher", "mammen", or "webb").

Type:: str

seed

Random seed used for bootstrap.

Type:: int or None

rank_deficient_action

How rank deficiency is handled ("warn", "error", "silent").

Type:: str

Methods

`summary`([alpha])	Generate formatted summary.
`print_summary`([alpha])	Print summary to stdout.
`to_dataframe`([level])	Convert results to DataFrame.

dose_response_att: DoseResponseCurve

dose_response_acrt: DoseResponseCurve

overall_att: float

overall_att_se: float

overall_att_t_stat: float

overall_att_p_value: float

overall_att_conf_int: Tuple[float, float]

overall_acrt: float

overall_acrt_se: float

overall_acrt_t_stat: float

overall_acrt_p_value: float

overall_acrt_conf_int: Tuple[float, float]

group_time_effects: Dict[Tuple[Any, Any], Dict[str, Any]]

dose_grid: ndarray

groups: List[Any]

time_periods: List[Any]

n_obs: int

n_treated_units: int

n_control_units: int

alpha: float = 0.05

control_group: str = 'never_treated'

degree: int = 3

num_knots: int = 0

base_period: str = 'varying'

anticipation: int = 0

n_bootstrap: int = 0

bootstrap_weights: str = 'rademacher'

seed: int | None = None

rank_deficient_action: str = 'warn'

covariates: List[str] | None = None

estimation_method: str = 'dr'

pscore_trim: float = 0.01

epv_threshold: float = 10.0

pscore_fallback: str = 'error'

treatment_type: str = 'continuous'

reference_dose: float | None = None

event_study_effects: Dict[int, Dict[str, Any]] | None = None

survey_metadata: Any | None = None

property att: float

property se: float

property conf_int: Tuple[float, float]

property p_value: float

property t_stat: float

property overall_se: float

property overall_conf_int: Tuple[float, float]

property overall_p_value: float

property overall_t_stat: float

property coef_var: float

SE / abs(overall ATT). NaN when ATT is 0 or SE non-finite.

Type:: Coefficient of variation

summary(alpha=None)[source]

Generate formatted summary.

Parameters:: alpha (float | None)
Return type:: str

print_summary(alpha=None)[source]

Print summary to stdout.

Parameters:: alpha (float | None)
Return type:: None

to_dict()[source]

Convert headline results to a dictionary.

Returns:: Canonical ATT inference row, the ACRT companion estimand, and scalar metadata. Detailed dose-response / event-study tables are available via to_dataframe(level=...).
Return type:: Dict[str, Any]

to_dataframe(level='dose_response')[source]

Convert results to DataFrame.

Parameters:: level (str, default="dose_response") – "dose_response", "group_time", or "event_study".
Return type:: DataFrame

property is_significant: bool: Check if overall ATT is significant.

property significance_stars: str: Significance stars for overall ATT.

__init__(dose_response_att, dose_response_acrt, overall_att, overall_att_se, overall_att_t_stat, overall_att_p_value, overall_att_conf_int, overall_acrt, overall_acrt_se, overall_acrt_t_stat, overall_acrt_p_value, overall_acrt_conf_int, group_time_effects, dose_grid, groups, time_periods, n_obs, n_treated_units, n_control_units, alpha=0.05, control_group='never_treated', degree=3, num_knots=0, base_period='varying', anticipation=0, n_bootstrap=0, bootstrap_weights='rademacher', seed=None, rank_deficient_action='warn', covariates=None, estimation_method='dr', pscore_trim=0.01, epv_threshold=10.0, pscore_fallback='error', treatment_type='continuous', reference_dose=None, event_study_effects=None, survey_metadata=None)

Parameters:

dose_response_att (DoseResponseCurve)
dose_response_acrt (DoseResponseCurve)
overall_att (float)
overall_att_se (float)
overall_att_t_stat (float)
overall_att_p_value (float)
overall_att_conf_int (Tuple[float, float])
overall_acrt (float)
overall_acrt_se (float)
overall_acrt_t_stat (float)
overall_acrt_p_value (float)
overall_acrt_conf_int (Tuple[float, float])
group_time_effects (Dict[Tuple[Any, Any], Dict[str, Any]])
dose_grid (ndarray)
groups (List[Any])
time_periods (List[Any])
n_obs (int)
n_treated_units (int)
n_control_units (int)
alpha (float)
control_group (str)
degree (int)
num_knots (int)
base_period (str)
anticipation (int)
n_bootstrap (int)
bootstrap_weights (str)
seed (int | None)
rank_deficient_action (str)
covariates (List[str] | None)
estimation_method (str)
pscore_trim (float)
epv_threshold (float)
pscore_fallback (str)
treatment_type (str)
reference_dose (float | None)
event_study_effects (Dict[int, Dict[str, Any]] | None)
survey_metadata (Any | None)

Return type:

None

DoseResponseCurve#

Dose-response curve container for ATT(d) or ACRT(d).

class diff_diff.continuous_did_results.DoseResponseCurve[source]

Bases: object

Dose-response curve from continuous DiD estimation.

dose_grid

Evaluation points, shape (n_grid,).

Type:: np.ndarray

effects

ATT(d) or ACRT(d) values, shape (n_grid,).

Type:: np.ndarray

se

Standard errors, shape (n_grid,).

Type:: np.ndarray

conf_int_lower

Lower CI bounds, shape (n_grid,).

Type:: np.ndarray

conf_int_upper

Upper CI bounds, shape (n_grid,).

Type:: np.ndarray

target

"att" or "acrt".

Type:: str

Methods

to_dataframe()

Convert to DataFrame with dose, effect, se, CI, t_stat, p_value.

dose_grid: ndarray

effects: ndarray

se: ndarray

conf_int_lower: ndarray

conf_int_upper: ndarray

target: str

p_value: ndarray | None = None

n_bootstrap: int = 0

df_survey: int | None = None

to_dataframe()[source]

Convert to DataFrame with dose, effect, se, CI, t_stat, p_value.

Return type:: DataFrame

__init__(dose_grid, effects, se, conf_int_lower, conf_int_upper, target, p_value=None, n_bootstrap=0, df_survey=None)

Parameters:

dose_grid (ndarray)
effects (ndarray)
se (ndarray)
conf_int_lower (ndarray)
conf_int_upper (ndarray)
target (str)
p_value (ndarray | None)
n_bootstrap (int)
df_survey (int | None)

Return type:

None

Example Usage#

Basic usage:

from diff_diff import ContinuousDiD, generate_continuous_did_data

data = generate_continuous_did_data(n_units=200, seed=42)

est = ContinuousDiD(n_bootstrap=199, seed=42)
results = est.fit(data, outcome='outcome', unit='unit',
                  time='period', first_treat='first_treat',
                  dose='dose', aggregate='dose')
results.print_summary()

Accessing dose-response curves:

# ATT(d) dose-response curve as DataFrame
att_df = results.dose_response_att.to_dataframe()
print(att_df[['dose', 'effect', 'se', 'p_value']])

# ACRT(d) dose-response curve
acrt_df = results.dose_response_acrt.to_dataframe()

# Overall summary parameters
print(f"Overall ATT: {results.overall_att:.3f} (SE: {results.overall_att_se:.3f})")
print(f"Overall ACRT: {results.overall_acrt:.3f} (SE: {results.overall_acrt_se:.3f})")

Event study aggregation:

# Dynamic effects (binarized ATT by relative period)
results_es = est.fit(data, outcome='outcome', unit='unit',
                     time='period', first_treat='first_treat',
                     dose='dose', aggregate='eventstudy')
es_df = results_es.to_dataframe(level='event_study')

Comparison with CallawaySantAnna#

Feature	ContinuousDiD	CallawaySantAnna
Treatment type	Continuous dose / intensity	Binary (treated / not treated)
Target parameter	ATT^loc (PT); ATT(d), ACRT(d), ATT^glob, ACRT^glob (SPT)	ATT(g,t), aggregated ATT
Smoothing	B-spline basis for dose-response	None (nonparametric group-time)
Dose-response curve	Yes (full curve with CIs)	No
Bootstrap	Multiplier bootstrap (optional)	Multiplier bootstrap (optional)
Control group	never_treated / not_yet_treated / lowest_dose	never_treated / not_yet_treated