diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 582d9deb..dfb271e6 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -22,7 +22,7 @@ repos: exclude_types: [svg] - id: check-yaml - id: check-added-large-files - exclude: &exclude_pattern 'iv_weak_instruments.ipynb' + exclude: &exclude_pattern '(iv_weak_instruments\.ipynb|cp_covid\.ipynb)' args: ["--maxkb=1500"] - repo: https://github.com/astral-sh/ruff-pre-commit rev: v0.14.0 diff --git a/0.14.0 b/0.14.0 new file mode 100644 index 00000000..e69de29b diff --git a/causalpy/__init__.py b/causalpy/__init__.py index 66031185..df397759 100644 --- a/causalpy/__init__.py +++ b/causalpy/__init__.py @@ -19,6 +19,7 @@ from causalpy.version import __version__ from .data import load_data +from .experiments.change_point_detection import ChangePointDetection from .experiments.diff_in_diff import DifferenceInDifferences from .experiments.instrumental_variable import InstrumentalVariable from .experiments.interrupted_time_series import InterruptedTimeSeries @@ -33,6 +34,7 @@ __all__ = [ "__version__", "DifferenceInDifferences", + "ChangePointDetection", "create_causalpy_compatible_class", "InstrumentalVariable", "InterruptedTimeSeries", diff --git a/causalpy/custom_exceptions.py b/causalpy/custom_exceptions.py index 89e74c8f..a45c4f81 100644 --- a/causalpy/custom_exceptions.py +++ b/causalpy/custom_exceptions.py @@ -37,3 +37,10 @@ class DataException(Exception): def __init__(self, message: str): self.message = message + + +class ModelException(Exception): + """Exception raised given when there is some error in user-provided model""" + + def __init__(self, message: str): + self.message = message diff --git a/causalpy/experiments/change_point_detection.py b/causalpy/experiments/change_point_detection.py new file mode 100644 index 00000000..043d909a --- /dev/null +++ b/causalpy/experiments/change_point_detection.py @@ -0,0 +1,542 @@ +# Copyright 2022 - 2025 The PyMC Labs Developers +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Interrupted Time Series Analysis + +This module implements interrupted time series (ITS) analysis for causal inference, +supporting both traditional scenarios where the intervention time is known and +advanced scenarios where the intervention time must be inferred from the data. + +Overview +-------- +Interrupted time series analysis is a quasi-experimental design used to evaluate +the impact of an intervention by comparing time series data before and after the +intervention occurs. This module provides a flexible framework that can handle: + +1. **Known intervention times**: Traditional ITS where you specify exactly when + the treatment occurred (e.g., policy implementation date) +2. **Unknown intervention times**: Advanced ITS where the model infers when an + intervention likely occurred based on observed changes in the data + +Treatment Time Handler Architecture +---------------------------------- +The core design pattern in this module is the Strategy pattern implemented through +the `TreatmentTimeHandler` hierarchy. This architecture was necessary because known +and unknown treatment times require fundamentally different approaches: + +**Why the Handler Architecture?** + +- **Data Processing**: Known times require splitting data at a specific point; + unknown times need the full dataset for inference +- **Model Training**: Known times train only on pre-intervention data; unknown + times train on all available data to detect the changepoint +- **Uncertainty Handling**: Known times have deterministic splits; unknown times + have probabilistic splits with confidence intervals +- **Visualization**: Different plotting strategies for certain vs. uncertain + intervention times + +**Handler Classes:** + +1. **TreatmentTimeHandler (Abstract Base Class)** + + - Defines the interface that all concrete handlers must implement + - Ensures consistent API regardless of whether treatment time is known/unknown + - Abstract methods: data_preprocessing, data_postprocessing, plot_intervention_line, + plot_impact_cumulative + - Optional method: plot_treated_counterfactual (only needed for unknown times) + +2. **KnownTreatmentTimeHandler** + + - Handles traditional ITS scenarios with predetermined intervention times + - **Data Preprocessing**: Filters data to pre-intervention period only for training + - **Data Postprocessing**: Creates clean pre/post splits at the known time point + - **Plotting**: Draws single vertical line at the intervention time + - **Use Case**: Policy evaluations, clinical trials, A/B tests with known start dates + +3. **UnknownTreatmentTimeHandler** + + - Handles advanced ITS scenarios where intervention time is inferred + - **Data Preprocessing**: Uses full dataset and constrains model's search window + - **Data Postprocessing**: Extracts inferred treatment time from posterior samples, + creates probabilistic pre/post splits, handles uncertainty propagation + - **Plotting**: Draws intervention line with uncertainty bands (HDI), shows + "treated counterfactual" predictions + - **Use Case**: Exploratory analysis, natural experiments, detecting unknown + structural breaks + +The handler pattern ensures that: + +- The main `InterruptedTimeSeries` class maintains a clean, unified API +- Different treatment time scenarios are handled with appropriate algorithms +- New handler types can be easily added (e.g., multiple intervention times) +- Code is maintainable and testable with clear separation of concerns + +The module automatically selects the appropriate handler based on the treatment_time +parameter and model type, providing a seamless user experience while maintaining +the flexibility to handle diverse analytical scenarios. +""" + +from typing import Iterable, List, Union + +import arviz as az +import numpy as np +import pandas as pd +import xarray as xr +from matplotlib import pyplot as plt +from patsy import dmatrices + +from causalpy.custom_exceptions import BadIndexException, DataException, ModelException +from causalpy.experiments.base import BaseExperiment +from causalpy.plot_utils import get_hdi_to_df, plot_xY +from causalpy.pymc_models import PyMCModel +from causalpy.utils import round_num + +LEGEND_FONT_SIZE = 12 + + +class ChangePointDetection(BaseExperiment): + """ + The class for detecting turning point in time series. + + :param data: + A pandas dataframe + :param formula: + A statistical model formula + :param treatment_time_range: + The time range when treatment could've occurred, + should be in reference to the data index + :param model: + A PyMC model + + Example + -------- + >>> import causalpy as cp + >>> df = ( + ... cp.load_data("its") + ... .assign(date=lambda x: pd.to_datetime(x["date"])) + ... .set_index("date") + ... ) + >>> seed = 42 + >>> result = cp.ChangePointDetection( + ... df, + ... time_range=None, + ... formula="y ~ 1 + t + C(month)", + ... model=cp.pymc_models.LinearChangePointDetection( + ... cp_effect_type="level", + ... sample_kwargs={ + ... "target_accept": 0.95, + ... "random_seed": seed, + ... "progressbar": False, + ... }, + ... ), + ... ) + """ + + expt_type = "Change Point Detection" + supports_ols = False + supports_bayes = True + + def __init__( + self, + data: pd.DataFrame, + formula: str, + time_range: Union[Iterable, None] = None, + model=None, + **kwargs, + ) -> None: + super().__init__(model=model) + + # rename the index to "obs_ind" + data.index.name = "obs_ind" + self.input_validation(data, time_range, model) + + # set experiment type - usually done in subclasses + self.expt_type = "Pre-Post Fit" + + self.time_range = time_range + self.formula = formula + + # Define the time interval over which the model will perform inference + model.set_time_range(self.time_range, data) + + # Preprocess the data according to the given formula + y, X = dmatrices(formula, data) + + self.outcome_variable_name = y.design_info.column_names[0] + self._y_design_info = y.design_info + self._x_design_info = X.design_info + self.labels = X.design_info.column_names + self.y, self.X = np.asarray(y), np.asarray(X) + + # turn into xarray.DataArray's + self.X = xr.DataArray( + self.X, + dims=["obs_ind", "coeffs"], + coords={ + "obs_ind": data.index, + "coeffs": self.labels, + }, + ) + self.y = xr.DataArray( + self.y, # Keep 2D shape + dims=["obs_ind", "treated_units"], + coords={"obs_ind": data.index, "treated_units": ["unit_0"]}, + ) + + # fit the model to the observed data + if isinstance(self.model, PyMCModel): + COORDS = { + "coeffs": self.labels, + "obs_ind": np.arange(self.X.shape[0]), + "treated_units": ["unit_0"], + } + idata = self.model.fit(X=self.X, y=self.y, coords=COORDS) + else: + raise ValueError("Model type not recognized") + + # score the goodness of fit to the pre-intervention data + self.score = self.model.score(X=self.X, y=self.y) + + # Getting inferred change point values + cp_samples = idata.posterior["change_point"].values + cp_mean = int(cp_samples.mean().item()) + + # Actual timestamp (index) corresponding to inferred change point + self.changepoint = data.index[cp_mean] + + # --- Slice data into pre/post change point --- + self.datapre = data.head(cp_mean) + self.datapost = data.iloc[cp_mean:] + + # --- Slice covariates into pre/post change point --- + self.pre_y = self.y.isel(obs_ind=slice(0, cp_mean)) + self.pre_X = self.X.isel(obs_ind=slice(0, cp_mean)) + self.post_y = self.y.isel(obs_ind=slice(cp_mean, None)) + self.post_X = self.X.isel(obs_ind=slice(cp_mean, None)) + + # --- Predict outcomes using the model --- + pred = model.predict(X=self.X) + self.pre_pred = pred.isel(obs_ind=slice(0, cp_mean)) + self.post_pred = pred.isel(obs_ind=slice(cp_mean, None)) + + # --- Estimate causal impact --- + impact = model.calculate_impact(y, pred) + self.pre_impact = impact.isel(obs_ind=slice(0, cp_mean)) + self.post_impact = impact.isel(obs_ind=slice(cp_mean, None)) + + # --- Create a mask to isolate post-change point period --- + # Timeline reshaped to match broadcasting with change point + # (Probably could be better implemented though) + timeline = [ + [[i for i in range(len(data))] for _ in range(len(cp_samples[0]))] + for _ in range(len(cp_samples)) + ] + timeline_broadcast = np.array(timeline) + tt_broadcast = cp_samples[:, :, None].astype(int) + mask = (timeline_broadcast >= tt_broadcast).astype(int) + mask = mask[:, :, np.newaxis, :] + post_impact_masked = impact * mask + + # --- Compute cumulative post-change point impact --- + post_impact_masked = impact * mask + self.post_impact_cumulative = model.calculate_cumulative_impact( + post_impact_masked + ) + + def input_validation(self, data, time_range, model): + """Validate the input data and model formula for correctness""" + if not hasattr(model, "set_time_range"): + raise ModelException("Provided model must have a 'set_time_range' method") + if time_range is not None and len(time_range) != 2: + raise DataException( + "Provided time_range must be of length 2 : (start, end)" + ) + if isinstance(data.index, pd.DatetimeIndex) and not ( + time_range is None + or ( + isinstance(time_range, Iterable) + and all(isinstance(t, pd.Timestamp) for t in time_range) + ) + ): + raise BadIndexException( + "If data.index is DatetimeIndex, time_range must " + "be of type Iterable[pd.Timestamp]." + ) + if not isinstance(data.index, pd.DatetimeIndex) and ( + isinstance(time_range, Iterable) + and all(isinstance(t, pd.Timestamp) for t in time_range) + ): + raise BadIndexException( + "If data.index is not DatetimeIndex, time_range must" + "not be of type Iterable[pd.Timestamp]." # noqa: E501 + ) + + def summary(self, round_to=None) -> None: + """Print summary of main results and model coefficients. + + :param round_to: + Number of decimals used to round results. Defaults to 2. Use "None" to return raw numbers + """ + print(f"{self.expt_type:=^80}") + print(f"Formula: {self.formula}") + self.print_coefficients(round_to) + + def _bayesian_plot( + self, round_to=None, **kwargs + ) -> tuple[plt.Figure, List[plt.Axes]]: + """ + Plot the results + + :param round_to: + Number of decimals used to round results. Defaults to 2. Use "None" to return raw numbers. + """ + counterfactual_label = "Counterfactual" + + fig, ax = plt.subplots(3, 1, sharex=True, figsize=(7, 8)) + # TOP PLOT -------------------------------------------------- + handles = [] + labels = [] + + # Treated counterfactual + # Plot predicted values after change point (with HDI) + h_line, h_patch = plot_xY( + self.datapre.index, + self.pre_pred["posterior_predictive"].mu.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "yellowgreen"}, + ) + + h_line, h_patch = plot_xY( + self.datapost.index, + self.post_pred["posterior_predictive"].mu.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "yellowgreen"}, + ) + + handles.append((h_line, h_patch)) + labels.append("Treated counterfactual") + + # pre-intervention period + h_line, h_patch = plot_xY( + self.datapre.index, + self.pre_pred["posterior_predictive"].mu_ts.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "C0"}, + ) + handles.append((h_line, h_patch)) + labels.append("Pre-intervention period") + + (h,) = ax[0].plot( + self.datapre.index, + self.pre_y.isel(treated_units=0) + if hasattr(self.pre_y, "isel") + else self.pre_y[:, 0], + "k.", + label="Observations", + ) + handles.append(h) + labels.append("Observations") + + # post intervention period + h_line, h_patch = plot_xY( + self.datapost.index, + self.post_pred["posterior_predictive"].mu_ts.isel(treated_units=0), + ax=ax[0], + plot_hdi_kwargs={"color": "C1"}, + ) + handles.append((h_line, h_patch)) + labels.append(counterfactual_label) + + ax[0].plot( + self.datapost.index, + self.post_y.isel(treated_units=0) + if hasattr(self.post_y, "isel") + else self.post_y[:, 0], + "k.", + ) + # Shaded causal effect + post_pred_mu = ( + az.extract(self.post_pred, group="posterior_predictive", var_names="mu_ts") + .isel(treated_units=0) + .mean("sample") + ) # Add .mean("sample") to get 1D array + h = ax[0].fill_between( + self.datapost.index, + y1=post_pred_mu, + y2=self.post_y.isel(treated_units=0) + if hasattr(self.post_y, "isel") + else self.post_y[:, 0], + color="C0", + alpha=0.25, + ) + handles.append(h) + labels.append("Causal impact") + + ax[0].set( + title=f""" + Pre-intervention Bayesian $R^2$: {round_num(self.score["unit_0_r2"], round_to)} + (std = {round_num(self.score["unit_0_r2_std"], round_to)}) + """ + ) + + # MIDDLE PLOT ----------------------------------------------- + plot_xY( + self.datapre.index, + self.pre_impact.isel(treated_units=0), + ax=ax[1], + plot_hdi_kwargs={"color": "C0"}, + ) + plot_xY( + self.datapost.index, + self.post_impact.isel(treated_units=0), + ax=ax[1], + plot_hdi_kwargs={"color": "C1"}, + ) + ax[1].axhline(y=0, c="k") + ax[1].fill_between( + self.datapost.index, + y1=self.post_impact.mean(["chain", "draw"]).isel(treated_units=0), + color="C0", + alpha=0.25, + label="Causal impact", + ) + ax[1].set(title="Causal Impact") + + # BOTTOM PLOT ----------------------------------------------- + # Concatenate the time indices + full_index = self.datapre.index.append(self.datapost.index) + ax[2].set(title="Cumulative Causal Impact") + plot_xY( + full_index, + self.post_impact_cumulative.isel(treated_units=0), + ax=ax[2], + plot_hdi_kwargs={"color": "C1"}, + ) + ax[2].axhline(y=0, c="k") + + # Plot vertical line marking change point (with HDI if it's inferred) + data = pd.concat([self.datapre, self.datapost]) + # Extract the HDI (uncertainty interval) of the change point + hdi = az.hdi(self.idata, var_names=["change_point"])["change_point"].values + x1 = data.index[int(hdi[0])] + x2 = data.index[int(hdi[1])] + + for i in [0, 1, 2]: + ymin, ymax = ax[i].get_ylim() + + # Vertical line for inferred change point + ax[i].plot( + [self.changepoint, self.changepoint], + [ymin, ymax], + ls="-", + lw=3, + color="r", + solid_capstyle="butt", + ) + + # Shaded region for HDI of change point + ax[i].fill_betweenx( + y=[ymin, ymax], + x1=x1, + x2=x2, + alpha=0.1, + color="r", + ) + + ax[0].legend( + handles=(h_tuple for h_tuple in handles), + labels=labels, + fontsize=LEGEND_FONT_SIZE, + ) + + return fig, ax + + def get_plot_data_bayesian(self, hdi_prob: float = 0.94) -> pd.DataFrame: + """ + Recover the data of the experiment along with the prediction and causal impact information. + + :param hdi_prob: + Prob for which the highest density interval will be computed. The default value is defined as the default from the :func:`arviz.hdi` function. + """ + if isinstance(self.model, PyMCModel): + hdi_pct = int(round(hdi_prob * 100)) + + pred_lower_col = f"pred_hdi_lower_{hdi_pct}" + pred_upper_col = f"pred_hdi_upper_{hdi_pct}" + impact_lower_col = f"impact_hdi_lower_{hdi_pct}" + impact_upper_col = f"impact_hdi_upper_{hdi_pct}" + + pre_data = self.datapre.copy() + post_data = self.datapost.copy() + + pre_data["prediction"] = ( + az.extract(self.pre_pred, group="posterior_predictive", var_names="mu") + .mean("sample") + .isel(treated_units=0) + .values + ) + post_data["prediction"] = ( + az.extract(self.post_pred, group="posterior_predictive", var_names="mu") + .mean("sample") + .isel(treated_units=0) + .values + ) + hdi_pre_pred = get_hdi_to_df( + self.pre_pred["posterior_predictive"].mu, hdi_prob=hdi_prob + ) + hdi_post_pred = get_hdi_to_df( + self.post_pred["posterior_predictive"].mu, hdi_prob=hdi_prob + ) + # Select the single unit from the MultiIndex results + pre_data[[pred_lower_col, pred_upper_col]] = hdi_pre_pred.xs( + "unit_0", level="treated_units" + ).set_index(pre_data.index) + post_data[[pred_lower_col, pred_upper_col]] = hdi_post_pred.xs( + "unit_0", level="treated_units" + ).set_index(post_data.index) + + pre_data["impact"] = ( + self.pre_impact.mean(dim=["chain", "draw"]).isel(treated_units=0).values + ) + post_data["impact"] = ( + self.post_impact.mean(dim=["chain", "draw"]) + .isel(treated_units=0) + .values + ) + hdi_pre_impact = get_hdi_to_df(self.pre_impact, hdi_prob=hdi_prob) + hdi_post_impact = get_hdi_to_df(self.post_impact, hdi_prob=hdi_prob) + # Select the single unit from the MultiIndex results + pre_data[[impact_lower_col, impact_upper_col]] = hdi_pre_impact.xs( + "unit_0", level="treated_units" + ).set_index(pre_data.index) + post_data[[impact_lower_col, impact_upper_col]] = hdi_post_impact.xs( + "unit_0", level="treated_units" + ).set_index(post_data.index) + + self.plot_data = pd.concat([pre_data, post_data]) + + return self.plot_data + else: + raise ValueError("Unsupported model type") + + def plot_change_point(self): + """ + display the posterior estimates of the change point + """ + if "change_point" not in self.idata.posterior.data_vars: + raise ValueError( + "Variable 'change_point' not found in inference data (idata)." + ) + + az.plot_trace(self.idata, var_names="change_point") diff --git a/causalpy/pymc_models.py b/causalpy/pymc_models.py index 2596ca4c..6bec6e54 100644 --- a/causalpy/pymc_models.py +++ b/causalpy/pymc_models.py @@ -886,3 +886,309 @@ class initialisation. idata_outcome.extend(pm.sample(**self.sample_kwargs)) return idata_outcome, model_outcome + + +class LinearChangePointDetection(PyMCModel): + r""" + Custom PyMC model to estimate one ChangePoint in time series. + + This model implements three types of changepoints: level shift, trend change, and impulse response. + While the underlying mathematical framework could theoretically be applied to other changepoint + detection problems, it has been specifically designed and tested for use in interrupted time + series causal inference settings. + + In words: + - `beta` represents the regression coefficients for the baseline signal `μ`. + - `tau` is the changepoint time, and `w` is a sigmoid function to smooth the transition. + - `level` and `trend` model a linear shift after the changepoint. + - `A` and `lambda` define an impulse response at the changepoint. + - `mu_in` combines the level, trend, and impulse contributions. + - `mu_ts` is the total mean, including baseline and intervention. + - `sigma` is the observation noise. + - Finally, `y` is drawn from a Normal distribution with mean `mu_ts` and standard deviation `sigma`. + + .. math:: + \beta &\sim \mathrm{Normal}(0, 5) \\ + \mu &= \beta \cdot X\\ + \\ + \tau &\sim \mathrm{Uniform}(\text{lower_bound}, \text{upper_bound}) \\ + w &= sigmoid(t-\tau) \\ + \\ + \text{level} &\sim \mathrm{Normal}(0, 5) \\ + \text{trend} &\sim \mathrm{Normal}(0, 0.5) \\ + A &\sim \mathrm{Normal}(0, 5) \\ + \lambda &\sim \mathrm{HalfNormal}(0, 5) \\ + \text{impulse} &= A \cdot exp(-\lambda \cdot |t-\tau|) \\ + \mu_{in} &= \text{level} + \text{trend} \cdot (t-\tau) + \text{impulse}\\ + \\ + \sigma &\sim \mathrm{HalfNormal}(0, 1) \\ + \mu_{ts} &= \mu + \mu_{in} \\ + \\ + y &\sim \mathrm{Normal}(\mu_{ts}, \sigma) + + Example + -------- + >>> import causalpy as cp + >>> import numpy as np + >>> from patsy import build_design_matrices, dmatrices + >>> from causalpy.pymc_models import LinearChangePointDetection + >>> data = cp.load_data("its") + >>> formula="y ~ 1 + t + C(month)" + >>> y, X = dmatrices(formula, data) + >>> outcome_variable_name = y.design_info.column_names[0] + >>> labels = X.design_info.column_names + >>> _y, _X = np.asarray(y), np.asarray(X) + >>> _X = xr.DataArray( + ... _X, + ... dims=["obs_ind", "coeffs"], + ... coords={ + ... "obs_ind": data.index, + ... "coeffs": labels, + ... }, + ... ) + >>> _y = xr.DataArray( + ... _y, + ... dims=["obs_ind", "treated_units"], + ... coords={ + ... "obs_ind": data.index, + ... "treated_units": ["unit_0"] + ... }, + ... ) + >>> COORDS = { + ... "coeffs": labels, + ... "obs_ind": np.arange(X.shape[0]), + ... "treated_units": ["unit_0"], + ... } + >>> model = LinearChangePointDetection(cp_effect_type="level", sample_kwargs={"draws" : 10, "tune":10, "progressbar":False}) + >>> model.set_time_range(None, data) + >>> model.fit(X=_X, y=_y, coords=COORDS) + Inference ... + """ + + default_priors = { + "beta": Prior("Normal", mu=0, sigma=5, dims=["treated_units", "coeffs"]), + "level": Prior("Normal", mu=0, sigma=5), + "trend": Prior("Normal", mu=0, sigma=5), + "impulse_amplitude": Prior("Normal", mu=0, sigma=5), + "impulse_decay_rate": Prior("HalfNormal", sigma=5), + "y_hat": Prior( + "Normal", + sigma=Prior("HalfNormal", sigma=5, dims=["treated_units"]), + dims=["obs_ind", "treated_units"], + ), + } + + def __init__( + self, + cp_effect_type: str | list[str], + cp_effect_param=None, + sample_kwargs=None, + ): + """ + Initializes the InterventionTimeEstimator model. + + :param cp_effect_type: Optional dictionary that specifies prior parameters for the + intervention effects. Expected keys are: + - "level": [mu, sigma] + - "trend": [mu, sigma] + - "impulse": [mu, sigma1, sigma2] + If a key is missing, the corresponding effect is ignored. + If the associated list is incomplete, default values will be used. + :param sample_kwargs: Optional dictionary of arguments passed to pm.sample(). + """ + + super().__init__(sample_kwargs, cp_effect_param) + + # Make sure we get a list of all expected effects + if isinstance(cp_effect_type, str): + self.cp_effect_type = [cp_effect_type] + else: + self.cp_effect_type = cp_effect_type + + def build_model(self, X, y, coords): + """ + Defines the PyMC model + + :param X: An array of the covariates + :param y: An array of values representing our outcome y + :param coords: Dictionary of named coordinates for PyMC variables (e.g., {"obs_ind": range(n_obs), "coeffs": range(n_covariates)}). + + Assumes the following attributes are already defined in self: + - self.timeline: the index of the column in X representing time. + - self.time_range: a tuple (lower_bound, upper_bound) for the intervention time. + - self.cp_effect_type: a dictionary specifying which intervention effects to include and their priors. + """ + + with self: + self.add_coords(coords) + + t = pm.Data("t", np.arange(len(X)), dims="obs_ind") + X = pm.Data("X", X, dims=["obs_ind", "coeffs"]) + y = pm.Data("y", y, dims=["obs_ind", "treated_units"]) + + lower_bound = pm.Data("lower_bound", self.time_range[0]) + upper_bound = pm.Data("upper_bound", self.time_range[1]) + + # --- Priors --- + # --- change_point unconstrained mapping --- + tau_un = pm.Normal("tau_un", 0, 1) + change_point = pm.Deterministic( + "change_point", + lower_bound + (upper_bound - 1 - lower_bound) * pm.math.sigmoid(tau_un), + ) + + delta_t = pm.Deterministic( + name="delta_t", + var=(t - change_point), + dims=["obs_ind"], + ) + beta = self.priors["beta"].create_variable("beta") + + # --- Intervention effect --- + mu_in_components = [] + + if "level" in self.cp_effect_type: + level = self.priors["level"].create_variable("level") + mu_in_components.append(level) + + if "trend" in self.cp_effect_type: + trend = self.priors["trend"].create_variable("trend") + mu_in_components.append(trend * delta_t) + + if "impulse" in self.cp_effect_type: + impulse_amplitude = self.priors["impulse_amplitude"].create_variable( + "impulse_amplitude" + ) + decay_rate = self.priors["impulse_decay_rate"].create_variable( + "impulse_decay_rate" + ) + impulse = pm.Deterministic( + "impulse", + impulse_amplitude * pm.math.exp(-decay_rate * pm.math.abs(delta_t)), + ) + mu_in_components.append(impulse) + + # --- Parameterization --- + weight = pm.math.sigmoid(delta_t) + # Compute and store the base time series + mu_ts = pm.Deterministic( + name="mu_ts", var=pt.dot(X, beta.T), dims=["obs_ind", "treated_units"] + ) + # Compute and store the modelled intervention effect + mu_in = ( + pm.Deterministic( + name="mu_in", + var=sum(mu_in_components), + ) + if len(mu_in_components) > 0 + else pm.Data( + name="mu_in", + vars=0, + ) + ) + + mu = pm.Deterministic( + "mu", + mu_ts + (weight * mu_in)[:, None], + dims=["obs_ind", "treated_units"], + ) + + # --- Likelihood --- + + # Likelihodd of the base time series and the intervention's effect + self.priors["y_hat"].create_likelihood_variable("y_hat", mu=mu, observed=y) + + def predict(self, X): + """ + Predict data given input data `X` + + .. caution:: + Results in KeyError if model hasn't been fit. + """ + + # Ensure random_seed is used in sample_prior_predictive() and + # sample_posterior_predictive() if provided in sample_kwargs. + random_seed = self.sample_kwargs.get("random_seed", None) + self._data_setter(X) + with self: # sample with new input data + pp = pm.sample_posterior_predictive( + self.idata, + var_names=["y_hat", "mu", "mu_ts", "mu_in"], + progressbar=False, + random_seed=random_seed, + ) + + # TODO: This is a bit of a hack. Maybe it could be done properly in _data_setter? + if isinstance(X, xr.DataArray) and "obs_ind" in X.coords: + pp["posterior_predictive"] = pp["posterior_predictive"].assign_coords( + obs_ind=X.obs_ind + ) + + return pp + + def _data_setter(self, X) -> None: + """ + Set data for the model. + + This method is used internally to register new data for the model for + prediction. + """ + n_obs = X.shape[0] + with self: + treated_units_coord = getattr(self, "coords", {}).get( + "treated_units", ["unit_0"] + ) + n_treated_unit = len(treated_units_coord) + pm.set_data( + { + "X": X, + "t": np.arange(n_obs), + "y": np.zeros((n_obs, n_treated_unit)), + }, + coords={"obs_ind": np.arange(n_obs)}, + ) + + def score(self, X, y) -> pd.Series: + """ + Score the Bayesian :math:`R^2` given inputs ``X`` and outputs ``y``. + """ + mu = self.predict(X) + mu_data = az.extract(mu, group="posterior_predictive", var_names="mu") + + scores = {} + + # Always iterate over treated_units dimension - no branching needed! + for i, unit in enumerate(mu_data.coords["treated_units"].values): + unit_mu = mu_data.sel(treated_units=unit).T # (sample, obs_ind) + unit_y = y.sel(treated_units=unit).data + unit_score = r2_score(unit_y, unit_mu.data) + scores[f"unit_{i}_r2"] = unit_score["r2"] + scores[f"unit_{i}_r2_std"] = unit_score["r2_std"] + + return pd.Series(scores) + + def calculate_impact( + self, y_true: xr.DataArray, y_pred: az.InferenceData + ) -> xr.DataArray: + impact = y_true - y_pred["posterior_predictive"]["mu_ts"] + return impact.transpose(..., "obs_ind") + + def set_time_range(self, time_range, data): + """ + Set time_range. + + :param time_range: tuple or None + If not None, a tuple of two values (start_label, end_label) that correspond + to index labels in the 't' column of the `data` DataFrame + :param data: pandas.DataFrame. + """ + if time_range is None: + self.time_range = ( + 0, + len(data), + ) + else: + self.time_range = ( + data.index.get_loc(time_range[0]), + data.index.get_loc(time_range[1]), + ) diff --git a/causalpy/tests/test_integration_pymc_examples.py b/causalpy/tests/test_integration_pymc_examples.py index e7795522..f5d8e34c 100644 --- a/causalpy/tests/test_integration_pymc_examples.py +++ b/causalpy/tests/test_integration_pymc_examples.py @@ -403,6 +403,110 @@ def test_its(mock_pymc_sample): ) +@pytest.mark.integration +def test_cp_covid(): + """ + Test ChangePoint experiment on COVID data. + + Loads data and checks: + 1. data is a dataframe + 2. causalpy.ChangePoint returns correct type + 3. the correct number of MCMC chains exists in the posterior inference data + 4. the correct number of MCMC draws exists in the posterior inference data + 5. the method get_plot_data returns a DataFrame with expected columns + """ + + df = ( + cp.load_data("covid") + .assign(date=lambda x: pd.to_datetime(x["date"])) + .set_index("date") + ) + time_range = (pd.to_datetime("2014-01-01"), pd.to_datetime("2022-01-01")) + + # Assert that we correctfully raise a ModelException if the given model can't predict InterventionTime + with pytest.raises(cp.custom_exceptions.ModelException) as exc_info: + cp.ChangePointDetection( + df, + time_range=time_range, + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearRegression(sample_kwargs=sample_kwargs), + ) + assert "Provided model must have a 'set_time_range' method" in str(exc_info.value) + + # Assert that we correctfully raise a DataException if + # - time_range is not None + # - and len(time_range) is not 2 + with pytest.raises(cp.custom_exceptions.DataException) as exc_info: + cp.ChangePointDetection( + df, + time_range=[0, 0, 0], + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearChangePointDetection( + cp_effect_type=["impulse", "level", "trend"], + sample_kwargs=sample_kwargs, + ), + ) + assert "Provided time_range must be of length 2 : (start, end)" in str( + exc_info.value + ) + + # Assert that we correctfully raise a BadIndexException if + # - time_range is not None + # - time_range is not of type Iterable[pd.TimeStamp] + # - DataIndex is of type pd.DatetimeIndex + with pytest.raises(cp.custom_exceptions.BadIndexException) as exc_info: + cp.ChangePointDetection( + df, + time_range=[0, 0], + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearChangePointDetection( + cp_effect_type=["impulse", "level", "trend"], + sample_kwargs=sample_kwargs, + ), + ) + assert ( + "If data.index is DatetimeIndex, time_range must be of type Iterable[pd.Timestamp]." + in str(exc_info.value) + ) + + result = cp.ChangePointDetection( + df, + time_range=time_range, + formula="standardize(deaths) ~ 0 + t + C(month) + standardize(temp)", # noqa E501 + model=cp.pymc_models.LinearChangePointDetection( + cp_effect_type=["impulse", "level", "trend"], + sample_kwargs=sample_kwargs, + ), + ) + assert isinstance(df, pd.DataFrame) + assert isinstance(result, cp.ChangePointDetection) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + result.summary() + fig, ax = result.plot() + assert isinstance(fig, plt.Figure) + # For multi-panel plots, ax should be an array of axes + assert isinstance(ax, np.ndarray) and all( + isinstance(item, plt.Axes) for item in ax + ), "ax must be a numpy.ndarray of plt.Axes" + # Test get_plot_data with default parameters + plot_data = result.get_plot_data() + assert isinstance(plot_data, pd.DataFrame), ( + "The returned object is not a pandas DataFrame" + ) + expected_columns = [ + "prediction", + "pred_hdi_lower_94", + "pred_hdi_upper_94", + "impact", + "impact_hdi_lower_94", + "impact_hdi_upper_94", + ] + assert set(expected_columns).issubset(set(plot_data.columns)), ( + f"DataFrame is missing expected columns {expected_columns}" + ) + + @pytest.mark.integration def test_its_covid(mock_pymc_sample): """ diff --git a/docs/source/_static/classes.png b/docs/source/_static/classes.png index 2dda20e6..50592de7 100644 Binary files a/docs/source/_static/classes.png and b/docs/source/_static/classes.png differ diff --git a/docs/source/_static/interrogate_badge.svg b/docs/source/_static/interrogate_badge.svg index 8734d55d..a00d0758 100644 --- a/docs/source/_static/interrogate_badge.svg +++ b/docs/source/_static/interrogate_badge.svg @@ -1,5 +1,5 @@ - interrogate: 95.8% + interrogate: 95.7% @@ -12,8 +12,8 @@ interrogate interrogate - 95.8% - 95.8% + 95.7% + 95.7% diff --git a/docs/source/_static/packages.png b/docs/source/_static/packages.png index 5a537cd0..0dd5a658 100644 Binary files a/docs/source/_static/packages.png and b/docs/source/_static/packages.png differ diff --git a/docs/source/notebooks/cp_covid.ipynb b/docs/source/notebooks/cp_covid.ipynb new file mode 100644 index 00000000..dc750ed5 --- /dev/null +++ b/docs/source/notebooks/cp_covid.ipynb @@ -0,0 +1,1262 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bayesian Change Point Detection\n", + "\n", + "Change Point Detection (CPD) estimates when a sudden, significant shift occurs in a time series. While Interrupted Time Series (ITS) analysis requires a known intervention date, CPD is a valuable tool to validate or refine that date by inferring the actual location of the structural break. This ensures the ITS analysis models the impact starting from when the effect truly began. \n", + "\n", + "In this notebook, we utilize a Bayesian model trained on the entire dataset to infer both the baseline parameters and the most probable location of the changepoint (e.g., a shift in level, impulse, or trend). The Bayesian method does not return a single date. Instead, it provides a full probability distribution over the changepoint's timing. This distribution directly quantifies the model's uncertainty and confidence regarding when the change truly occurred." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jeanv\\miniconda3\\envs\\CausalPy\\Lib\\site-packages\\pymc_extras\\model\\marginal\\graph_analysis.py:10: FutureWarning: `pytensor.graph.basic.io_toposort` was moved to `pytensor.graph.traversal.io_toposort`. Calling it from the old location will fail in a future release.\n", + " from pytensor.graph.basic import io_toposort\n" + ] + } + ], + "source": [ + "# Imports ...\n", + "\n", + "import arviz as az\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import causalpy as cp\n", + "\n", + "seed = 0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using the `LinearChangePointDetection` PyMC model\n", + "\n", + "The `LinearChangePointDetection` is designed to infer *when* an intervention likely occurred, based on the **type of effect** you expect it to have produced. \n", + "\n", + "Instead of specifying the exact time of change, you describe the expected *form* of the intervention: a sudden jump (`level`), a gradual shift (`trend`), or a short-lived anomaly (`impulse`). Optionally, you can narrow the search by providing a plausible time window. \n", + "\n", + "Under the hood, the model evaluates candidate intervention points and estimates how well each one explains the observed data through Bayesian inference. At its core, it relies on a linear regression, to which the intervention effects are added: \n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\beta &\\sim \\mathcal{N}(0, 5) &\\text{Coefficient prior} \\\\\n", + "\\sigma &\\sim \\text{HalfNormal}(1) &\\text{Noise prior} \\\\\n", + "\\mu &= X \\cdot \\beta \\\\\n", + "y &\\sim \\mathcal{N}(\\mu, \\sigma) &\\text{Likelihood}\n", + "\\end{align}\n", + "$$\n", + "\n", + "In a Bayesian context, the change point location ($t$) is treated as a parameter to be inferred. While a Uniform distribution over the time window might seem intuitive, Hamiltonian Monte Carlo (HMC) samplers like NUTS perform poorly on bounded parameters.To ensure robust and efficient sampling, the model employs a reparameterization trick. The location parameter ($t$) is mapped from an unconstrained latent variable ($\\tau$) using the logistic (sigmoid) function\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\tau &\\sim \\mathcal{N}(0, 1) &\\text{Unconstrained laten variable}\\\\\n", + "t &\\sim \\text{lower bound} + (\\text{upper bound} - \\text{lower bound}) \\cdot \\text{sigmoid}(\\tau) &\\text{Mapped change point location}\n", + "\\end{align}\n", + "$$\n", + "\n", + "This transformation allows the sampler to operate on the unbounded $\\tau$ space while ensuring that the inferred time $t$ remains strictly within the defined plausible time window." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example 1: Level Change\n", + "\n", + "In this example, we apply the `LinearChangePointDetection` model to an interrupted time series in its simplest form: a **level change**. \n", + "\n", + "A level change corresponds to a sudden shift in the mean level of the series, occurring at the time of the intervention. In this case, the model can be expressed as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\text{level} &\\sim \\mathcal{N}(0, 5) \\\\\n", + "\\mu_{\\text{level}} &= \\sigma(t) \\cdot \\text{level} \\\\\n", + "y &\\sim \\mathcal{N}(\\mu + \\mu_{\\text{level}}, \\sigma)\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $\\sigma(t) = \\frac{1}{1 + e^{-t}}$ is the logistic sigmoid function that encodes the timing of the intervention.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate the Data ...\n", + "np.random.seed(seed)\n", + "\n", + "n = 100\n", + "tau_true = 40\n", + "x = np.arange(n)\n", + "y = np.where(x >= tau_true, 2, 0.0) + np.random.normal(1, 0.4, size=n)\n", + "df = pd.DataFrame({\"t\": x, \"y\": y})\n", + "\n", + "plt.figure(figsize=(10, 3))\n", + "plt.plot(x, y)\n", + "plt.axvline(tau_true, color=\"red\", linestyle=\"--\", label=\"True treatment time\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, when initializing the InterventionTimeEstimator model, we only need to Ensure that ``LinearChangePointDetection``'s ``cp_effect_type`` includes the key ``\"level\"``. After that, the model can be used as is with the ``ChangePointDetection`` class by setting the ``time_range`` parameter to ``None``." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from causalpy.experiments.change_point_detection import ChangePointDetection\n", + "from causalpy.pymc_models import LinearChangePointDetection" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, level, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "Sampling: [beta, level, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"level\", sample_kwargs={\"sample_seed\": seed, \"progressbar\": False}\n", + ")\n", + "\n", + "result = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + t\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, this example produces two plots.\n", + "\n", + "The first displays three graphs: \n", + "- the **model’s predictions**, showing both the fitted curve *with* and *without* the inferred causal effect, \n", + "- the **estimated causal impact** which isolates the effect by removing it from the predictions,\n", + "- and the **cumulative impact over time**.\n", + "\n", + "The second plot shows the posterior distribution of the inferred treatment time.\n", + "\n", + ":::{note} that the R² score is computed using the full predictions, that is, including the causal effect. In contrast, the causal impact is calculated by subtracting the estimated effect from the predictions.:::" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example 2 : Trend Change\n", + "\n", + "In this example, we illustrate how to use the `LinearChangePointDetection` when the time series exhibits a **trend change**. \n", + "\n", + "A trend change corresponds to a gradual shift in the slope of the series starting at the intervention time. The model can be expressed as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\text{trend} &\\sim \\mathcal{N}(0, 0.5) \\\\\n", + "\\mu_{\\text{trend}} &= \\sigma(t) \\cdot \\text{trend} \\cdot (\\text{time} - t) \\\\\n", + "y &\\sim \\mathcal{N}(\\mu + \\mu_{\\text{trend}}, \\sigma)\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate the data ...\n", + "# Set random seed for reproducibility\n", + "np.random.seed(42)\n", + "\n", + "n = 100\n", + "intervention_point = 60\n", + "time = np.arange(n)\n", + "\n", + "pre_trend = 0.5 * time[:intervention_point] + np.random.normal(\n", + " scale=5, size=intervention_point\n", + ")\n", + "post_trend = (\n", + " 0.5 * time[intervention_point]\n", + " + 3.0 * (time[intervention_point:] - time[intervention_point])\n", + " + np.random.normal(scale=5, size=n - intervention_point)\n", + ")\n", + "\n", + "synthetic_series = np.concatenate([pre_trend, post_trend])\n", + "\n", + "# Create DataFrame\n", + "df = pd.DataFrame({\"time\": time, \"y\": synthetic_series})\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 3))\n", + "plt.plot(df[\"time\"], df[\"y\"])\n", + "plt.axvline(\n", + " x=intervention_point, color=\"red\", linestyle=\"--\", label=\"True treatment time\"\n", + ")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Compared to the previous example, the only change is that we use ``\"trend\"`` instead of ``\"level\"`` for the ``cp_effect_type``, to model a change in slope rather than a level shift." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, trend, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 50 seconds.\n", + "Sampling: [beta, tau_un, trend, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"trend\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + time\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example 3 : Impulse\n", + "\n", + "In this final example, we'll demonstrate how to apply the ``LinearChangePointDetection`` model to data that display an impulse-like effect. Here how it works under the hood :\n", + "\n", + "$$\n", + "\\begin{align}\n", + "A &\\sim \\mathcal{N}(0, 5) \\\\\n", + "\\lambda &\\sim \\text{HalfNormal}(0, 5) \\\\\n", + "\\mu_{\\text{impulse}} &= \\sigma(t) \\cdot A e^{- \\lambda (\\text{time} - t)} \\\\\n", + "y &\\sim \\mathcal{N}(\\mu + \\mu_{\\text{impulse}}, \\sigma)\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate data ...\n", + "\n", + "np.random.seed(42)\n", + "n = 100\n", + "t = np.arange(n)\n", + "\n", + "intercept = 2\n", + "trend = intercept\n", + "\n", + "# Impulse parameters\n", + "t0 = 50\n", + "A = 5\n", + "decay_rate = 0.1\n", + "impulse = np.zeros(n)\n", + "impulse[t0:] = A * np.exp(-decay_rate * (t[t0:] - t0))\n", + "\n", + "# Bruit\n", + "noise = np.random.normal(0, 0.5, size=n)\n", + "\n", + "# Série finale\n", + "y = trend + impulse + noise\n", + "\n", + "df = pd.DataFrame({\"y\": y, \"time\": t})\n", + "\n", + "# Plot ...\n", + "\n", + "plt.figure(figsize=(10, 3))\n", + "plt.plot(t, y, color=\"royalblue\")\n", + "plt.axvline(t0, color=\"red\", linestyle=\":\", label=\"True treatment time\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember to set ``cp_effect_type`` to ``\"impulse\"``." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, impulse_amplitude, impulse_decay_rate, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 104 seconds.\n", + "Sampling: [beta, impulse_amplitude, impulse_decay_rate, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"impulse\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + time\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Narrowing the Inference Window\n", + "\n", + "Now, you can also constrain the inference window by passing a time_range=(start, end) argument, where start and end correspond to the row indices or timestamps of your dataframe:\n", + "\n", + "- `time_range=(80,100)`\n", + "\n", + "or\n", + "\n", + "- `time_range=(pd.to_datetime(\"2016-01-31\"),pd.to_datetime(\"2018-01-31\"))`\n", + "\n", + "This can significantly improve inference speed and robustness, especially when dealing with long or noisy time series.\n", + "\n", + ":::{tip}\n", + "If you’re unsure about the intervention period, try starting with ``time_range=None`` and inspect the posterior.\n", + ":::\n", + "\n", + "Keeping the same example, if we now increase the noise in the data and reduce the level change, the advantage of using a restricted time_range becomes evident:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Making the example\n", + "\n", + "n = 100\n", + "tau_true = 40\n", + "x = np.arange(n)\n", + "y = np.where(x >= tau_true, 1.60, 0.0) + np.random.normal(1, 1.30, size=n)\n", + "df = pd.DataFrame({\"t\": x, \"y\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, level, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 94 seconds.\n", + "There were 53 divergences after tuning. Increase `target_accept` or reparameterize.\n", + "The rhat statistic is larger than 1.01 for some parameters. This indicates problems during sampling. See https://arxiv.org/abs/1903.08008 for details\n", + "The effective sample size per chain is smaller than 100 for some parameters. A higher number is needed for reliable rhat and ess computation. See https://arxiv.org/abs/1903.08008 for details\n", + "Sampling: [beta, level, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, level, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 113 seconds.\n", + "Sampling: [beta, level, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "# First run: unconstrained treatment time — the model scans the entire time axis.\n", + "# With noisy data, this leads to a wide posterior and uncertain inference.\n", + "\n", + "model1 = LinearChangePointDetection(\n", + " cp_effect_type=\"level\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result1 = ChangePointDetection(\n", + " data=df,\n", + " time_range=None,\n", + " formula=\"standardize(y) ~ 1 + t\",\n", + " model=model1,\n", + ")\n", + "\n", + "# Second run: constrain the treatment time to a plausible window (t in [20, 60]).\n", + "# This narrows the posterior, improves inference stability, and speeds up sampling.\n", + "\n", + "model2 = LinearChangePointDetection(\n", + " cp_effect_type=\"level\",\n", + " sample_kwargs={\"sample_seed\": seed, \"progressbar\": False},\n", + ")\n", + "\n", + "result2 = ChangePointDetection(\n", + " data=df,\n", + " time_range=(20, 60),\n", + " formula=\"standardize(y) ~ 1 + t\",\n", + " model=model2,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we’ve increased the noise, we can already observe issues with sampling. The warning “_The rhat statistic is larger than 1.01 for some parameters_” indicates convergence problems: the model struggles to infer from the data, and the parameters fail to stabilize around their true values. In contrast, the model with a fixed time range does not trigger such warnings.\n", + "\n", + "Looking at the forest plot, the difference becomes even clearer. The model with a given time range not only recovers the true treatment time more reliably, but it also does so with substantially less uncertainty. While the unconstrained model isn't even centered near the correct value, its wide intervals and convergence issues mean that we cannot trust its estimates." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_forest(\n", + " [result1.idata, result2.idata],\n", + " var_names=[\"change_point\"],\n", + " model_names=[\"Model without time range\", \"Model with time range\"],\n", + " combined=True,\n", + " hdi_prob=0.95,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Specifying the effect\n", + "\n", + "The effects also can be specified using a dictionary passed to the `cp_effect_param` arguments :\n", + "\n", + "```\n", + "model = InterventionTimeEstimator(\n", + " cp_effect_type=[\"level\", \"impulse\"],\n", + " cp_effect_param={\"impulse\":[mu, sigma1, sigma2]}\n", + " )\n", + "```\n", + "\n", + ":::{note}\n", + "You must provide all parameters if you choose to set them manually. If you leave the list empty or not fully furnished, default priors will be used.\n", + ":::\n", + "\n", + "| Effect type | Description | Parameters required |\n", + "|-------------|-------------|---------------------|\n", + "|`level`| Permanent jump in the time series level | `[mu, sigma]` for N(mu, sigma) |\n", + "|`trend`| Change in the trend slope | `[mu, sigma]` for N(mu, sigma) |\n", + "|`impulse`| Sudden change with decay | `[mu, sigma1, sigma2]` where:

- Amplitude ~ N(mu, sigma1)
- decay ~ HalfNormal(sigma2) |\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Summary: How to use ``LinearChangePointDetection``\n", + "\n", + "\n", + "1. **Select the intervention effect type**\n", + "\n", + " Choose the expected effect(s) of the intervention: \"impulse\", \"level\", or \"trend\".\n", + "\n", + "2. **Configure priors for each effect**\n", + " \n", + " Either:\n", + "\n", + " - use default priors or\n", + "\n", + " - specify custom priors (e.g. ``cp_effect_param={\"impulse\": [mu, sigma1, sigma2]}``).\n", + "\n", + "3. **(Optional) Limit the inference window**\n", + "\n", + " Use ``time_range=(start, end)`` to restrict inference to a specific time interval.\n", + "\n", + "4. **Pass the model to ChangePointDetection**" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Change Point Detection : Real Data Example" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tempdeathsyearmonthtpre
date
2006-01-013.849124200610True
2006-02-013.442664200621True
2006-03-013.949207200632True
2006-04-017.440645200643True
2006-05-0110.742425200654True
\n", + "
" + ], + "text/plain": [ + " temp deaths year month t pre\n", + "date \n", + "2006-01-01 3.8 49124 2006 1 0 True\n", + "2006-02-01 3.4 42664 2006 2 1 True\n", + "2006-03-01 3.9 49207 2006 3 2 True\n", + "2006-04-01 7.4 40645 2006 4 3 True\n", + "2006-05-01 10.7 42425 2006 5 4 True" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load Data ...\n", + "\n", + "df = (\n", + " cp.load_data(\"covid\")\n", + " .assign(date=lambda x: pd.to_datetime(x[\"date\"]))\n", + " .set_index(\"date\")\n", + ")\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the data ...\n", + "\n", + "plt.plot(df.index, df[\"deaths\"]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking at the data, we observe a noticeable increase in the number of deaths between years 2017 and 2019. After this period, the values seem to return to their previous level.\n", + "\n", + "In this example, we will build a model using the \"impulse\" effect to represent this transient deviation. We won’t specify the exact location of the intervention, instead we will give a time range and hope the model will infer it from the data." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "model = LinearChangePointDetection(\n", + " cp_effect_type=\"impulse\",\n", + " sample_kwargs={\"random_seed\": seed, \"progressbar\": False},\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the analysis\n", + "\n", + "Optionally, we can guide the inference by specifying a time_range as a tuple, for example, restricting the intervention to occur between years 2014 and 2022. Leaving `time_range=None` allows the model to search freely over all possible timestamps, but adding a constraint typically speeds up inference and focuses the posterior on plausible regions.\n", + "\n", + ":::{note}\n", + "The `random_seed` keyword argument for the PyMC sampler is not necessary. We use it here so that the results are reproducible.\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [tau_un, beta, impulse_amplitude, impulse_decay_rate, y_hat_sigma]\n", + "Sampling 4 chains for 1_000 tune and 1_000 draw iterations (4_000 + 4_000 draws total) took 107 seconds.\n", + "Sampling: [beta, impulse_amplitude, impulse_decay_rate, tau_un, y_hat, y_hat_sigma]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n", + "Sampling: [y_hat]\n" + ] + } + ], + "source": [ + "result = ChangePointDetection(\n", + " df,\n", + " time_range=(pd.to_datetime(\"2014-01-01\"), pd.to_datetime(\"2022-01-01\")),\n", + " formula=\"standardize(deaths) ~ 0 + t + C(month) + standardize(temp)\",\n", + " model=model,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the results\n", + "\n", + ":::{note}\n", + "\n", + "The model estimates the latent time series mu by combining two components:\n", + "\n", + "- `mu_ts`: the part inferred from the user-defined formula (e.g. time + month),\n", + "\n", + "- `mu_in`: the contribution from the intervention effect.\n", + "\n", + "In the plots, we display `mu_ts` in blue, the baseline prediction based on the formula, to better highlight the causal impact of the intervention. This makes it easier to see how the observed data diverge from what would be expected without the effect. In the first one, you may also see `mu` in green.\n", + "\n", + "In contrast, evaluation metrics like R² and standard deviation are computed using `mu`, which includes both the formula and the intervention effect.\n", + "As a result, R² may appear higher than what the plots suggest.\n", + ":::" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is also possible to plot the posterior distribution of the changepoint :" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result.plot_change_point();" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================Pre-Post Fit==================================\n", + "Formula: standardize(deaths) ~ 0 + t + C(month) + standardize(temp)\n", + "Model coefficients:\n", + " C(month)[1] 0.79, 94% HDI [0.37, 1.2]\n", + " C(month)[2] -0.61, 94% HDI [-1, -0.23]\n", + " C(month)[3] -0.35, 94% HDI [-0.69, -0.021]\n", + " C(month)[4] -0.64, 94% HDI [-0.92, -0.37]\n", + " C(month)[5] -0.73, 94% HDI [-1, -0.45]\n", + " C(month)[6] -0.81, 94% HDI [-1.2, -0.45]\n", + " C(month)[7] -0.69, 94% HDI [-1.1, -0.23]\n", + " C(month)[8] -0.97, 94% HDI [-1.4, -0.55]\n", + " C(month)[9] -0.89, 94% HDI [-1.2, -0.54]\n", + " C(month)[10] -0.62, 94% HDI [-0.88, -0.35]\n", + " C(month)[11] -0.71, 94% HDI [-1, -0.41]\n", + " C(month)[12] -0.37, 94% HDI [-0.76, 0.0097]\n", + " t 0.0051, 94% HDI [0.0039, 0.0064]\n", + " standardize(temp) -0.29, 94% HDI [-0.54, -0.052]\n", + " y_hat_sigma 0.5, 94% HDI [0.45, 0.56]\n" + ] + } + ], + "source": [ + "result.summary()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As well as the model coefficients, we might be interested in the average causal impact and average cumulative causal impact.\n", + "\n", + ":::{note}\n", + "Better output for the summary statistics are in progress!\n", + ":::" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we ask for summary statistics of the causal impact over the entire post-intervention period." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "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", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
mu_ts[unit_0]0.5410.0680.4120.6690.0010.0012932.03257.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk \\\n", + "mu_ts[unit_0] 0.541 0.068 0.412 0.669 0.001 0.001 2932.0 \n", + "\n", + " ess_tail r_hat \n", + "mu_ts[unit_0] 3257.0 1.0 " + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "az.summary(result.post_impact.mean(\"obs_ind\"))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + ":::{warning}\n", + "Care must be taken with the mean impact statistic. It only makes sense to use this statistic if it looks like the intervention had a lasting (and roughly constant) effect on the outcome variable. If the effect is transient, then clearly there will be a lot of post-intervention period where the impact of the intervention has 'worn off'. If so, then it will be hard to interpret the mean impacts real meaning.\n", + ":::" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also ask for the summary statistics of the _cumulative_ causal impact." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "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", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
mu_ts[unit_0]14.5191.81511.2518.0970.0340.0232922.03311.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk \\\n", + "mu_ts[unit_0] 14.519 1.815 11.25 18.097 0.034 0.023 2922.0 \n", + "\n", + " ess_tail r_hat \n", + "mu_ts[unit_0] 3311.0 1.0 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get index of the final time point\n", + "index = result.post_impact_cumulative.obs_ind.max()\n", + "# grab the posterior distribution of the cumulative impact at this final time point\n", + "last_cumulative_estimate = result.post_impact_cumulative.sel({\"obs_ind\": index})\n", + "# get summary stats\n", + "az.summary(last_cumulative_estimate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References\n", + "\n", + "- Kay H. Brodersen. Fabian Gallusser. Jim Koehler. Nicolas Remy. Steven L. Scott. \"Inferring causal impact using Bayesian structural time-series models.\" Ann. Appl. Stat. 9 (1) 247 - 274, March 2015. https://doi.org/10.1214/14-AOAS788\n", + "- Davis Berlind, Lorenzo Cappello, Oscar Hernan Madrid Padilla. \"A Bayesian framework for change-point detection with uncertainty quantification\", https://doi.org/10.48550/arXiv.2507.01558" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "CausalPy", + "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.13.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/notebooks/index.md b/docs/source/notebooks/index.md index 17eaa40c..4987a06a 100644 --- a/docs/source/notebooks/index.md +++ b/docs/source/notebooks/index.md @@ -40,6 +40,7 @@ did_pymc_banks.ipynb its_skl.ipynb its_pymc.ipynb its_covid.ipynb +its_no_treatment_time.ipynb ::: :::{toctree}