diff --git a/causalpy/__init__.py b/causalpy/__init__.py index 5587fb3e..09384669 100644 --- a/causalpy/__init__.py +++ b/causalpy/__init__.py @@ -41,4 +41,5 @@ "RegressionKink", "skl_models", "SyntheticControl", + "variable_selection_priors", ] diff --git a/causalpy/experiments/instrumental_variable.py b/causalpy/experiments/instrumental_variable.py index 1e65627f..93403579 100644 --- a/causalpy/experiments/instrumental_variable.py +++ b/causalpy/experiments/instrumental_variable.py @@ -51,6 +51,16 @@ class InstrumentalVariable(BaseExperiment): If priors are not specified we will substitute MLE estimates for the beta coefficients. Example: ``priors = {"mus": [0, 0], "sigmas": [1, 1], "eta": 2, "lkj_sd": 2}``. + vs_prior_type : str or None, default=None + Type of variable selection prior: 'spike_and_slab', 'horseshoe', or None. + If None, uses standard normal priors. + vs_hyperparams : dict, optional + Hyperparameters for variable selection priors. Only used if vs_prior_type + is not None. + binary_treatment : bool, default=False + A indicator for whether the treatment to be modelled is binary or not. + Determines which PyMC model we use to model the joint outcome and + treatment. Example -------- @@ -85,6 +95,16 @@ class InstrumentalVariable(BaseExperiment): ... formula=formula, ... model=InstrumentalVariableRegression(sample_kwargs=sample_kwargs), ... ) + >>> # With variable selection + >>> iv = cp.InstrumentalVariable( + ... instruments_data=instruments_data, + ... data=data, + ... instruments_formula=instruments_formula, + ... formula=formula, + ... model=InstrumentalVariableRegression(sample_kwargs=sample_kwargs), + ... vs_prior_type="spike_and_slab", + ... vs_hyperparams={"slab_sigma": 5.0}, + ... ) """ supports_ols = False @@ -98,6 +118,9 @@ def __init__( formula: str, model: BaseExperiment | None = None, priors: dict | None = None, + vs_prior_type=None, + vs_hyperparams=None, + binary_treatment=False, **kwargs: dict, ) -> None: super().__init__(model=model) @@ -107,6 +130,9 @@ def __init__( self.formula = formula self.instruments_formula = instruments_formula self.model = model + self.vs_prior_type = vs_prior_type + self.vs_hyperparams = vs_hyperparams or {} + self.binary_treatment = binary_treatment self.input_validation() y, X = dmatrices(formula, self.data) @@ -130,15 +156,33 @@ def __init__( COORDS = {"instruments": self.labels_instruments, "covariates": self.labels} self.coords = COORDS if priors is None: - priors = { - "mus": [self.ols_beta_first_params, self.ols_beta_second_params], - "sigmas": [1, 1], - "eta": 2, - "lkj_sd": 1, - } + if binary_treatment: + # Different default priors for binary treatment + priors = { + "mus": [self.ols_beta_first_params, self.ols_beta_second_params], + "sigmas": [1, 1], + "sigma_U": 1.0, + "rho_bounds": [-0.99, 0.99], + } + else: + # Original continuous treatment priors + priors = { + "mus": [self.ols_beta_first_params, self.ols_beta_second_params], + "sigmas": [1, 1], + "eta": 2, + "lkj_sd": 1, + } self.priors = priors self.model.fit( # type: ignore[call-arg,union-attr] - X=self.X, Z=self.Z, y=self.y, t=self.t, coords=COORDS, priors=self.priors + X=self.X, + Z=self.Z, + y=self.y, + t=self.t, + coords=COORDS, + priors=self.priors, + vs_prior_type=vs_prior_type, + vs_hyperparams=vs_hyperparams, + binary_treatment=self.binary_treatment, ) def input_validation(self) -> None: @@ -159,10 +203,8 @@ def input_validation(self) -> None: if check_binary: warnings.warn( """Warning. The treatment variable is not Binary. - This is not necessarily a problem but it violates - the assumption of a simple IV experiment. - The coefficients should be interpreted appropriately.""", - UserWarning, + We will use the multivariate normal likelihood + for continuous treatment.""", stacklevel=2, ) diff --git a/causalpy/pymc_models.py b/causalpy/pymc_models.py index 8517b4f7..4f9ba54f 100644 --- a/causalpy/pymc_models.py +++ b/causalpy/pymc_models.py @@ -27,6 +27,7 @@ from pymc_extras.prior import Prior from causalpy.utils import round_num +from causalpy.variable_selection_priors import VariableSelectionPrior class PyMCModel(pm.Model): @@ -677,7 +678,10 @@ def build_model( # type: ignore y: np.ndarray, t: np.ndarray, coords: dict[str, Any], - priors: dict[str, Any], + priors, + vs_prior_type=None, + vs_hyperparams=None, + binary_treatment=False, ) -> None: """Specify model with treatment regression and focal regression data and priors. @@ -700,48 +704,127 @@ def build_model( # type: ignore Dictionary of priors for the mus and sigmas of both regressions. Example: ``priors = {"mus": [0, 0], "sigmas": [1, 1], "eta": 2, "lkj_sd": 2}``. + vs_prior_type: An optional string. Can be "spike_and_slab" + or "horseshoe" or "normal + vs_hyperparams: An optional dictionary of priors for the + variable selection hyperparameters + binary_treatment: A flag for determining the relevant + likelihood to be used. + """ # --- Priors --- with self: self.add_coords(coords) - beta_t = pm.Normal( - name="beta_t", - mu=priors["mus"][0], - sigma=priors["sigmas"][0], - dims="instruments", - ) - beta_z = pm.Normal( - name="beta_z", - mu=priors["mus"][1], - sigma=priors["sigmas"][1], - dims="covariates", - ) - sd_dist = pm.Exponential.dist(priors["lkj_sd"], shape=2) - chol, corr, sigmas = pm.LKJCholeskyCov( - name="chol_cov", - eta=priors["eta"], - n=2, - sd_dist=sd_dist, - ) - # compute and store the covariance matrix - pm.Deterministic(name="cov", var=pt.dot(l=chol, r=chol.T)) - - # --- Parameterization --- - mu_y = pm.Deterministic(name="mu_y", var=pt.dot(X, beta_z)) - # focal regression - mu_t = pm.Deterministic(name="mu_t", var=pt.dot(Z, beta_t)) - # instrumental regression - mu = pm.Deterministic(name="mu", var=pt.stack(tensors=(mu_y, mu_t), axis=1)) - - # --- Likelihood --- - pm.MvNormal( - name="likelihood", - mu=mu, - chol=chol, - observed=np.stack(arrays=(y.flatten(), t.flatten()), axis=1), - shape=(X.shape[0], 2), - ) + + if vs_prior_type and ("mus" in priors or "sigmas" in priors): + warnings.warn( + "Variable selection priors specified. " + "The 'mus' and 'sigmas' in the priors dict will be ignored " + "for beta coefficients. Only 'eta' and 'lkj_sd' will be used.", + stacklevel=2, + ) + + # Create coefficient priors + if vs_prior_type: + # Use variable selection priors + self.vs_prior_treatment = VariableSelectionPrior( + vs_prior_type, vs_hyperparams + ) + self.vs_prior_outcome = VariableSelectionPrior( + vs_prior_type, vs_hyperparams + ) + + beta_t = self.vs_prior_treatment.create_prior( + name="beta_t", n_params=Z.shape[1], dims="instruments", X=Z + ) + + beta_z = self.vs_prior_outcome.create_prior( + name="beta_z", n_params=X.shape[1], dims="covariates", X=X + ) + else: + # Use standard normal priors + beta_t = pm.Normal( + name="beta_t", + mu=priors["mus"][0], + sigma=priors["sigmas"][0], + dims="instruments", + ) + beta_z = pm.Normal( + name="beta_z", + mu=priors["mus"][1], + sigma=priors["sigmas"][1], + dims="covariates", + ) + + if binary_treatment: + # Binary treatment formulation with correlated latent errors + sigma_U = pm.Exponential("sigma_U", priors.get("sigma_U", 1.0)) + + # Correlation parameter with bounds + rho_lower = priors.get("rho_bounds", [-0.99, 0.99])[0] + rho_upper = priors.get("rho_bounds", [-0.99, 0.99])[1] + + # Use tanh transform to keep correlation in valid range + rho_unconstr = pm.Normal("rho_unconstr", 0, 0.5) + rho = pm.Deterministic("rho", pm.math.tanh(rho_unconstr)) + + # Clip to ensure numerical stability + rho_clipped = pt.clip(rho, rho_lower + 0.01, rho_upper - 0.01) + + # Cholesky decomposition for correlated errors + inverse_rho = pm.math.sqrt(pm.math.maximum(1 - rho_clipped**2, 1e-12)) + chol = pt.stack([[sigma_U, 0.0], [sigma_U * rho_clipped, inverse_rho]]) + + # Draw latent errors + eps_raw = pm.Normal("eps_raw", 0, 1, shape=(X.shape[0], 2)) + eps = pm.Deterministic("eps", pt.dot(eps_raw, chol.T)) + + U = eps[:, 0] # Outcome error + V = eps[:, 1] # Treatment error + + # Treatment equation (logit link for binary treatment) + mu_treatment = pm.Deterministic("mu_t", pt.dot(Z, beta_t) + V) + p_t = pm.math.invlogit(mu_treatment) + pm.Bernoulli("likelihood_treatment", p=p_t, observed=t.flatten()) + + # Outcome equation + mu_outcome = pm.Deterministic("mu_y", pt.dot(X, beta_z) + U) + pm.Normal( + "likelihood_outcome", + mu=mu_outcome, + sigma=sigma_U, + observed=y.flatten(), + ) + + else: + sd_dist = pm.Exponential.dist(priors["lkj_sd"], shape=2) + chol, _, _ = pm.LKJCholeskyCov( + name="chol_cov", + eta=priors["eta"], + n=2, + sd_dist=sd_dist, + ) + # compute and store the covariance matrix + pm.Deterministic(name="cov", var=pt.dot(l=chol, r=chol.T)) + + # --- Parameterization --- + mu_y = pm.Deterministic(name="mu_y", var=pt.dot(X, beta_z)) + # focal regression + mu_t = pm.Deterministic(name="mu_t", var=pt.dot(Z, beta_t)) + # instrumental regression + mu = pm.Deterministic( + name="mu", var=pt.stack(tensors=(mu_y, mu_t), axis=1) + ) + + # --- Likelihood --- + pm.MvNormal( + name="likelihood", + mu=mu, + chol=chol, + observed=np.stack(arrays=(y.flatten(), t.flatten()), axis=1), + shape=(X.shape[0], 2), + ) def sample_predictive_distribution(self, ppc_sampler: str | None = "jax") -> None: """Function to sample the Multivariate Normal posterior predictive @@ -772,50 +855,35 @@ def sample_predictive_distribution(self, ppc_sampler: str | None = "jax") -> Non ) ) - def fit( # type: ignore + def fit( # type: ignore[override] self, - X: np.ndarray, - Z: np.ndarray, - y: np.ndarray, - t: np.ndarray, - coords: dict[str, Any], - priors: dict[str, Any], - ppc_sampler: str | None = None, - ) -> az.InferenceData: - """Draw samples from posterior distribution and potentially from - the prior and posterior predictive distributions. - - Parameters - ---------- - X : np.ndarray - Array used to predict our outcome y. - Z : np.ndarray - Array used to predict our treatment variable t. - y : np.ndarray - Array of values representing our focal outcome y. - t : np.ndarray - Array representing the treatment variable. - coords : dict - Dictionary with coordinate names for named dimensions. - priors : dict - Dictionary of priors for the model. - ppc_sampler : str, optional - Sampler for posterior predictive distribution. Can be 'jax', - 'pymc', or None. Defaults to None, so the user can determine - if they wish to spend time sampling the posterior predictive - distribution independently. - - Returns - ------- - az.InferenceData - InferenceData object containing the samples. + X, + Z, + y, + t, + coords, + priors, + ppc_sampler=None, + vs_prior_type=None, + vs_hyperparams=None, + binary_treatment: bool = False, + ): # type: ignore[override] + """Draw samples from posterior distribution and potentially + from the prior and posterior predictive distributions. The + fit call can take values for the + ppc_sampler = ['jax', 'pymc', None] + We default to None, so the user can determine if they wish + to spend time sampling the posterior predictive distribution + independently. """ # Ensure random_seed is used in sample_prior_predictive() and # sample_posterior_predictive() if provided in sample_kwargs. # Use JAX for ppc sampling of multivariate likelihood - self.build_model(X, Z, y, t, coords, priors) + self.build_model( + X, Z, y, t, coords, priors, vs_prior_type, vs_hyperparams, binary_treatment + ) with self: self.idata = pm.sample(**self.sample_kwargs) self.sample_predictive_distribution(ppc_sampler=ppc_sampler) @@ -919,6 +987,7 @@ def fit_outcome_model( normal_outcome: bool = True, spline_component: bool = False, winsorize_boundary: float = 0.0, + spline_knots: int = 30, ) -> tuple[az.InferenceData, pm.Model]: """ Fit a Bayesian outcome model using covariates and previously estimated propensity scores. @@ -959,6 +1028,9 @@ def fit_outcome_model( If we wish to winsorize the propensity score this can be set to clip the high and low values of the propensity at 0 + winsorize_boundary and 1-winsorize_boundary + spline_knots: int, default 30 + The number of knots we use in the 0 - 1 interval to create our spline function + Returns ------- idata_outcome : arviz.InferenceData @@ -1028,11 +1100,11 @@ class initialisation. "beta_ps_spline", priors["beta_ps"][0], priors["beta_ps"][1], - size=34, + size=spline_knots + 4, ) B = dmatrix( "bs(ps, knots=knots, degree=3, include_intercept=True, lower_bound=0, upper_bound=1) - 1", - {"ps": p, "knots": np.linspace(0, 1, 30)}, + {"ps": p, "knots": np.linspace(0, 1, spline_knots)}, ) B_f = np.asarray(B, order="F") splines_summed = pm.Deterministic( diff --git a/causalpy/tests/test_integration_pymc_examples.py b/causalpy/tests/test_integration_pymc_examples.py index 9024845c..e7fe2995 100644 --- a/causalpy/tests/test_integration_pymc_examples.py +++ b/causalpy/tests/test_integration_pymc_examples.py @@ -684,6 +684,116 @@ def test_iv_reg(mock_pymc_sample): result.get_plot_data() +@pytest.mark.integration +def test_iv_binary_treatment(mock_pymc_sample): + df = cp.load_data("risk") + df["binary_trt"] = np.random.binomial(1, 0.5, len(df)) + instruments_formula = "binary_trt ~ 1 + risk + logmort0" + formula = "loggdp ~ 1 + binary_trt + risk" + instruments_data = df[["risk", "logmort0", "binary_trt"]] + data = df[["loggdp", "risk", "binary_trt"]] + + result = cp.InstrumentalVariable( + instruments_data=instruments_data, + data=data, + instruments_formula=instruments_formula, + formula=formula, + model=cp.pymc_models.InstrumentalVariableRegression( + sample_kwargs=sample_kwargs + ), + binary_treatment=True, + ) + result.model.sample_predictive_distribution(ppc_sampler="pymc") + assert isinstance(df, pd.DataFrame) + assert isinstance(data, pd.DataFrame) + assert isinstance(instruments_data, pd.DataFrame) + assert isinstance(result, cp.InstrumentalVariable) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + with pytest.raises(NotImplementedError): + result.get_plot_data() + assert "rho" in result.model.named_vars + + +@pytest.mark.integration +def test_iv_reg_vs_prior(mock_pymc_sample): + df = cp.load_data("risk") + instruments_formula = "risk ~ 1 + logmort0" + formula = "loggdp ~ 1 + risk" + instruments_data = df[["risk", "logmort0"]] + data = df[["loggdp", "risk"]] + + result = cp.InstrumentalVariable( + instruments_data=instruments_data, + data=data, + instruments_formula=instruments_formula, + formula=formula, + model=cp.pymc_models.InstrumentalVariableRegression( + sample_kwargs=sample_kwargs + ), + vs_prior_type="spike_and_slab", + vs_hyperparams={"pi_alpha": 5}, + ) + result.model.sample_predictive_distribution(ppc_sampler="pymc") + assert isinstance(df, pd.DataFrame) + assert isinstance(data, pd.DataFrame) + assert isinstance(instruments_data, pd.DataFrame) + assert isinstance(result, cp.InstrumentalVariable) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + with pytest.raises(NotImplementedError): + result.get_plot_data() + assert "gamma_beta_t" in result.model.named_vars + assert "pi_beta_t" in result.model.named_vars + summary = result.model.vs_prior_outcome.get_inclusion_probabilities( + result.idata, "beta_z" + ) + assert isinstance(summary, pd.DataFrame) + with pytest.raises(ValueError): + summary = result.model.vs_prior_outcome.get_shrinkage_factors( + result.idata, "beta_z" + ) + + +@pytest.mark.integration +def test_iv_reg_vs_prior_hs(mock_pymc_sample): + df = cp.load_data("risk") + instruments_formula = "risk ~ 1 + logmort0" + formula = "loggdp ~ 1 + risk" + instruments_data = df[["risk", "logmort0"]] + data = df[["loggdp", "risk"]] + + result = cp.InstrumentalVariable( + instruments_data=instruments_data, + data=data, + instruments_formula=instruments_formula, + formula=formula, + model=cp.pymc_models.InstrumentalVariableRegression( + sample_kwargs=sample_kwargs + ), + vs_prior_type="horseshoe", + ) + result.model.sample_predictive_distribution(ppc_sampler="pymc") + assert isinstance(df, pd.DataFrame) + assert isinstance(data, pd.DataFrame) + assert isinstance(instruments_data, pd.DataFrame) + assert isinstance(result, cp.InstrumentalVariable) + assert len(result.idata.posterior.coords["chain"]) == sample_kwargs["chains"] + assert len(result.idata.posterior.coords["draw"]) == sample_kwargs["draws"] + with pytest.raises(NotImplementedError): + result.get_plot_data() + assert "tau_beta_t" in result.model.named_vars + assert "tau_beta_z" in result.model.named_vars + summary = result.model.vs_prior_outcome.get_shrinkage_factors( + result.idata, "beta_z" + ) + assert isinstance(summary, pd.DataFrame) + with pytest.raises(ValueError): + summary = result.model.vs_prior_outcome.get_inclusion_probabilities( + result.idata, "beta_z" + ) + + @pytest.mark.integration def test_inverse_prop(mock_pymc_sample): """Test the InversePropensityWeighting class.""" diff --git a/causalpy/tests/test_variable_selection_priors.py b/causalpy/tests/test_variable_selection_priors.py new file mode 100644 index 00000000..1b464be6 --- /dev/null +++ b/causalpy/tests/test_variable_selection_priors.py @@ -0,0 +1,125 @@ +# 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. + +import numpy as np +import pymc as pm +import pytest + +from causalpy.variable_selection_priors import ( + HorseshoePrior, + SpikeAndSlabPrior, + VariableSelectionPrior, + create_variable_selection_prior, +) + + +@pytest.fixture +def sample_data(): + """Generate sample design matrix for testing.""" + rng = np.random.default_rng(42) + n_obs = 100 + n_features = 5 + X = rng.normal(size=(n_obs, n_features)) + return X + + +@pytest.fixture +def coords(): + """Generate sample coordinates for PyMC models.""" + return {"features": [f"x_{i}" for i in range(5)]} + + +def test_create_variable_in_model_context(coords): + """Test that create_variable works in PyMC model context.""" + prior = SpikeAndSlabPrior(dims="features") + + with pm.Model(coords=coords) as model: + beta = prior.create_variable("beta") + + # Check that beta was created + assert "beta" in model.named_vars + assert beta.name == "beta" + + # Check that intermediate variables were created + assert "pi_beta" in model.named_vars + assert "beta_raw" in model.named_vars + assert "gamma_beta" in model.named_vars + + +def test_create_variable_in_model_context_horseshoe(coords): + """Test that create_variable works in PyMC model context.""" + prior = HorseshoePrior(dims="features") + + with pm.Model(coords=coords) as model: + beta = prior.create_variable("beta") + + # Check that beta was created + assert "beta" in model.named_vars + assert beta.name == "beta" + + # Check that intermediate variables were created + assert "tau_beta" in model.named_vars + assert "lambda_beta" in model.named_vars + assert "c2_beta" in model.named_vars + assert "lambda_tilde_beta" in model.named_vars + assert "beta_raw" in model.named_vars + + +def test_create_prior_spike_and_slab(coords): + """Test create_prior for spike-and-slab.""" + vs_prior = VariableSelectionPrior("spike_and_slab", hyperparams={"pi_alpha": 5}) + + with pm.Model(coords=coords) as model: + beta = vs_prior.create_prior(name="beta", n_params=5, dims="features") + + assert "beta" in model.named_vars + assert beta.name == "beta" + + +def test_create_prior_horseshoe(coords, sample_data): + """Test create_prior for horseshoe.""" + vs_prior = VariableSelectionPrior("horseshoe") + + with pm.Model(coords=coords) as model: + beta = vs_prior.create_prior( + name="beta", n_params=5, dims="features", X=sample_data + ) + + assert "beta" in model.named_vars + assert beta.name == "beta" + + +def test_create_prior_normal(coords, sample_data): + """Test create_prior for horseshoe.""" + vs_prior = VariableSelectionPrior("normal") + + with pm.Model(coords=coords) as model: + beta = vs_prior.create_prior(name="beta", n_params=5, dims="features") + + assert "beta" in model.named_vars + assert beta.name == "beta" + + +def test_convenience_function_with_custom_hyperparams(coords): + """Test convenience function with custom hyperparameters.""" + with pm.Model(coords=coords) as model: + _ = create_variable_selection_prior( + prior_type="spike_and_slab", + name="beta", + n_params=5, + dims="features", + hyperparams={"slab_sigma": 5}, + ) + + assert "beta" in model.named_vars diff --git a/causalpy/variable_selection_priors.py b/causalpy/variable_selection_priors.py new file mode 100644 index 00000000..e484b7fb --- /dev/null +++ b/causalpy/variable_selection_priors.py @@ -0,0 +1,594 @@ +# 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. +""" +Generic variable selection priors for PyMC models using pymc-extras Prior class. + +This module provides reusable prior specifications that can be applied to any +PyMC model with coefficient vectors (beta parameters). Supports spike-and-slab +and horseshoe priors for automatic variable selection and shrinkage, built on +top of the pymc-extras Prior infrastructure. +""" + +from typing import Any + +import numpy as np +import pandas as pd +import pymc as pm +import pytensor.tensor as pt +from pymc_extras.prior import Prior + + +def _relaxed_bernoulli_transform( + p: float | pt.TensorVariable, temperature: float = 0.1 +): + """ + Transform function for relaxed (continuous) Bernoulli distribution. + + This provides a continuous approximation to a Bernoulli distribution, + useful for gradient-based inference. As temperature → 0, this approaches + a true binary distribution. + + Parameters + ---------- + p : float or PyMC variable + Probability parameter. + temperature : float, default=0.1 + Temperature parameter (lower = more binary). + + Returns + ------- + function + Transform function that takes uniform random variable. + """ + + def transform(u): + logit_p = pt.log(p) - pt.log(1 - p) + return pm.math.sigmoid((logit_p + pt.log(u) - pt.log(1 - u)) / temperature) + + return transform + + +class SpikeAndSlabPrior: + """ + Spike-and-slab prior using pymc-extras Prior class. + + Creates a mixture prior with a point mass at zero (spike) and a diffuse + normal distribution (slab), implemented as: + + .. math:: + \beta_{j} = \gamma_{j} \cdot \beta_{j}^{\text{raw}} \\ + \beta_{j}^{\text{raw}} \sim \mathcal{N}(0, \sigma_{\text{slab}}^{2}), \qquad + \gamma_{j} \in [0,1]. + + Parameters + ---------- + pi_alpha : float, default=2 + Beta prior alpha for selection probability + pi_beta : float, default=2 + Beta prior beta for selection probability + slab_sigma : float, default=2 + Standard deviation of slab (non-zero) component + temperature : float, default=0.1 + Relaxation parameter for binary approximation (lower = more binary) + dims : str or tuple, optional + Dimension names for the coefficient vector + + Example + ------- + >>> import pymc as pm + >>> from causalpy.variable_selection_priors import SpikeAndSlabPrior + >>> spike_slab = SpikeAndSlabPrior(dims="features") + >>> coords = {"features": ["a", "b", "c", "d", "e"]} + >>> with pm.Model(coords=coords) as model: + ... beta = spike_slab.create_variable("beta") + """ + + def __init__( + self, + pi_alpha: float = 2, + pi_beta: float = 2, + slab_sigma: float = 2, + temperature: float = 0.1, + dims: str | tuple | None = None, + ): + self.pi_alpha = pi_alpha + self.pi_beta = pi_beta + self.slab_sigma = slab_sigma + self.temperature = temperature + self.dims = dims if isinstance(dims, tuple) or dims is None else (dims,) + + def create_variable(self, name: str) -> pm.Deterministic: + """ + Create spike-and-slab variable. + + Parameters + ---------- + name : str + Name for the coefficient vector + + Returns + ------- + pm.Deterministic + Coefficient vector with spike-and-slab prior + """ + # Selection probability using Prior class + pi_prior = Prior("Beta", alpha=self.pi_alpha, beta=self.pi_beta) + pi = pi_prior.create_variable(f"pi_{name}") + + # Raw coefficients (slab component) using Prior class + slab_prior = Prior("Normal", mu=0, sigma=self.slab_sigma, dims=self.dims) + beta_raw = slab_prior.create_variable(f"{name}_raw") + + # Selection indicators using relaxed Bernoulli + # We use Uniform and transform it + u = pm.Uniform(f"gamma_{name}_u", 0, 1, dims=self.dims) + transform_fn = _relaxed_bernoulli_transform(pi, self.temperature) + gamma = pm.Deterministic(f"gamma_{name}", transform_fn(u), dims=self.dims) + + # Actual coefficients + return pm.Deterministic(name, gamma * beta_raw, dims=self.dims) + + +class HorseshoePrior: + """ + Regularized horseshoe prior using pymc-extras Prior class. + + Provides continuous shrinkage with heavy tails, allowing strong signals + to escape shrinkage while weak signals are dampened: + + .. math:: + \beta_{j} & = \tau \cdot \lambda_{j} \cdot \beta_{j}^{raw} \\ + \lambda_{j} & = \sqrt{ \dfrac{c^{2}\lambda_{j}^{2}}{c^{2} + \tau^{2}\lambda_{j}^{2}} } + + Parameters + ---------- + tau0 : float, optional + Global shrinkage parameter. If None, computed from data. + nu : float, default=3 + Degrees of freedom for half-t prior on tau + c2_alpha : float, default=2 + InverseGamma alpha for regularization parameter + c2_beta : float, default=2 + InverseGamma beta for regularization parameter + dims : str or tuple, optional + Dimension names for the coefficient vector + + Example + ------- + >>> import pymc as pm + >>> from causalpy.variable_selection_priors import HorseshoePrior + >>> horseshoe = HorseshoePrior(dims="features") + >>> coords = {"features": ["a", "b", "c", "d", "e"]} + >>> with pm.Model(coords=coords) as model: + ... beta = horseshoe.create_variable("beta") + """ + + def __init__( + self, + tau0: float | None = None, + nu: float = 3, + c2_alpha: float = 2, + c2_beta: float = 2, + dims: str | tuple | None = None, + ): + self.tau0 = tau0 + self.nu = nu + self.c2_alpha = c2_alpha + self.c2_beta = c2_beta + self.dims = dims if isinstance(dims, tuple) or dims is None else (dims,) + + def create_variable(self, name: str) -> pm.Deterministic: + """ + Create horseshoe variable. + + Parameters + ---------- + name : str + Name for the coefficient vector + + Returns + ------- + pm.Deterministic + Coefficient vector with horseshoe prior + """ + # Global shrinkage using Prior class + tau_prior = Prior("HalfStudentT", nu=self.nu, sigma=self.tau0 or 1.0) + tau = tau_prior.create_variable(f"tau_{name}") + + # Local shrinkage parameters using Prior class + lambda_prior = Prior("HalfCauchy", beta=1.0, dims=self.dims) + lambda_ = lambda_prior.create_variable(f"lambda_{name}") + + # Regularization parameter using Prior class + c2_prior = Prior("InverseGamma", alpha=self.c2_alpha, beta=self.c2_beta) + c2 = c2_prior.create_variable(f"c2_{name}") + + # Regularized local shrinkage + lambda_tilde = pm.Deterministic( + f"lambda_tilde_{name}", + pm.math.sqrt(c2 * lambda_**2 / (c2 + tau**2 * lambda_**2)), + dims=self.dims, + ) + + # Raw coefficients using Prior class + raw_prior = Prior("Normal", mu=0, sigma=1, dims=self.dims) + beta_raw = raw_prior.create_variable(f"{name}_raw") + + # Actual coefficients + return pm.Deterministic(name, beta_raw * lambda_tilde * tau, dims=self.dims) + + +class VariableSelectionPrior: + """ + Factory for creating variable selection priors on coefficient vectors. + + This class provides a unified interface for different types of variable + selection priors that can be applied to any beta coefficient in a PyMC model. + Built on top of pymc-extras Prior class for consistency and interoperability. + + Supported prior types: + - 'spike_and_slab': Mixture prior with near-zero spike and diffuse slab + - 'horseshoe': Continuous shrinkage with adaptive regularization + - 'normal': Standard normal prior (no selection, for comparison) + + Parameters + ---------- + prior_type : str + Type of prior: 'spike_and_slab', 'horseshoe', or 'normal' + hyperparams : dict, optional + Hyperparameters specific to the chosen prior type. If None, defaults are used. + + For 'spike_and_slab': + - pi_alpha: float (default=2) - Beta prior alpha for selection probability + - pi_beta: float (default=2) - Beta prior beta for selection probability + - slab_sigma: float (default=2) - SD of slab (non-zero) component + - temperature: float (default=0.1) - Relaxation parameter for binary approximation + + For 'horseshoe': + - tau0: float (default=None) - Global shrinkage, auto-computed if None + - nu: float (default=3) - Degrees of freedom for half-t prior on tau + - c2_alpha: float (default=2) - InverseGamma alpha for regularization + - c2_beta: float (default=2) - InverseGamma beta for regularization + + For 'normal': + - mu: float or array (default=0) - Prior mean + - sigma: float or array (default=1) - Prior SD + + Example + ------- + >>> import pymc as pm + >>> from causalpy.variable_selection_priors import VariableSelectionPrior + >>> # Create spike-and-slab prior + >>> vs_prior = VariableSelectionPrior("spike_and_slab") + >>> coords = {"features": ["a", "b", "c", "d", "e"]} + >>> with pm.Model(coords=coords) as model: + ... # Create coefficients with variable selection + ... beta = vs_prior.create_prior(name="beta", n_params=5, dims="features") + """ + + def __init__(self, prior_type: str, hyperparams: dict[str, Any] | None = None): + """Initialize the variable selection prior factory.""" + self.prior_type = prior_type.lower() + self.hyperparams = hyperparams or {} + + if self.prior_type not in ["spike_and_slab", "horseshoe", "normal"]: + raise ValueError( + f"Unknown prior_type: {prior_type}. " + "Must be 'spike_and_slab', 'horseshoe', or 'normal'" + ) + + # Will be set when create_prior is called + self._prior_instance = None + + def _get_default_hyperparams( + self, n_params: int, X: np.ndarray | None = None + ) -> dict[str, Any]: + """ + Get default hyperparameters for the chosen prior type. + + Parameters + ---------- + n_params : int + Number of parameters (dimension of beta vector) + X : array-like, optional + Design matrix for computing data-adaptive defaults (horseshoe only) + + Returns + ------- + dict + Default hyperparameters + """ + if self.prior_type == "spike_and_slab": + return { + "pi_alpha": 2, + "pi_beta": 2, + "slab_sigma": 2, + "temperature": 0.1, + } + + elif self.prior_type == "horseshoe": + # Compute tau0 using rule of thumb from Piironen & Vehtari (2017) + if X is not None: + p = n_params + p0 = min(5.0, p / 2) # Expected number of nonzero coefficients + sigma_est = 1.0 + n = X.shape[0] + tau0 = (p0 / (p - p0)) * (sigma_est / np.sqrt(n)) + else: + # Fallback if no data provided + tau0 = 1.0 / np.sqrt(n_params) + + return { + "tau0": tau0, + "nu": 3, + "c2_alpha": 2, + "c2_beta": 2, + } + + else: # normal + return { + "mu": 0, + "sigma": 1, + } + + def create_prior( + self, + name: str, + n_params: int, + dims: str | tuple | None = None, + X: np.ndarray | None = None, + hyperparams: dict[str, Any] | None = None, + ) -> pm.Deterministic: + """ + Create the specified prior on a coefficient vector. + + This is the main method to use. It creates the appropriate prior type + based on the configuration and returns the PyMC variable. + + Parameters + ---------- + name : str + Name for the coefficient vector (e.g., 'beta', 'b', 'coef') + n_params : int + Number of parameters (length of coefficient vector) + dims : str or tuple, optional + Dimension name(s) for the coefficient vector + X : array-like, optional + Design matrix for computing data-adaptive hyperparameters + (used only for horseshoe priors) + hyperparams : dict, optional + Override default hyperparameters for this specific prior instance + + Returns + ------- + PyMC variable + The coefficient vector with the specified prior + + Example + ------- + >>> import pymc as pm + >>> import pandas as pd + >>> from causalpy.variable_selection_priors import VariableSelectionPrior + >>> vs_prior = VariableSelectionPrior("spike_and_slab") + >>> coords = {"features": ["a", "b", "c", "d", "e"]} + >>> with pm.Model(coords=coords) as model: + ... beta = vs_prior.create_prior("beta", n_params=4, dims="features") + """ + # Merge instance and call-specific hyperparameters + default_hp = self._get_default_hyperparams(n_params, X) + merged_hp = {**default_hp, **self.hyperparams} + if hyperparams: + merged_hp.update(hyperparams) + + # Normalize dims + if isinstance(dims, str): + dims = (dims,) + + # Create the appropriate prior + if self.prior_type == "spike_and_slab": + self._prior_instance = SpikeAndSlabPrior( + pi_alpha=merged_hp["pi_alpha"], + pi_beta=merged_hp["pi_beta"], + slab_sigma=merged_hp["slab_sigma"], + temperature=merged_hp["temperature"], + dims=dims, + ) # type: ignore[assignment] + return self._prior_instance.create_variable(name) # type: ignore[attr-defined] + + elif self.prior_type == "horseshoe": + self._prior_instance = HorseshoePrior( + tau0=merged_hp["tau0"], + nu=merged_hp["nu"], + c2_alpha=merged_hp["c2_alpha"], + c2_beta=merged_hp["c2_beta"], + dims=dims, + ) # type: ignore[assignment] + return self._prior_instance.create_variable(name) # type: ignore[attr-defined] + + else: # normal + # Use Prior class directly for normal + normal_prior = Prior( + "Normal", mu=merged_hp["mu"], sigma=merged_hp["sigma"], dims=dims + ) + return normal_prior.create_variable(name) + + def get_inclusion_probabilities( + self, idata, param_name: str, threshold: float = 0.5 + ) -> pd.DataFrame: + """ + Extract variable inclusion probabilities from fitted model. + + Only applicable for spike-and-slab priors. Returns the posterior + probability that each coefficient is "selected" (non-zero). + + Parameters + ---------- + idata : arviz.InferenceData + Fitted model inference data + param_name : str + Name of the coefficient parameter (must match name in create_prior) + threshold : float, default=0.5 + Threshold for considering a variable "selected" + + Returns + ------- + dict + Dictionary with keys: + - 'probabilities': Array of inclusion probabilities per coefficient + - 'selected': Boolean array indicating which are selected + - 'gamma_mean': Mean of gamma (indicator) variables + + Raises + ------ + ValueError + If prior_type is not 'spike_and_slab' or gamma variables not found + + """ + if self.prior_type != "spike_and_slab": + raise ValueError( + "Inclusion probabilities only available for 'spike_and_slab' priors" + ) + + gamma_name = f"gamma_{param_name}" + + if gamma_name not in idata.posterior: + raise ValueError( + f"Could not find '{gamma_name}' in posterior. " + f"Make sure you used the correct parameter name." + ) + + import arviz as az + + # Extract gamma values + gamma = az.extract(idata.posterior[gamma_name]) + + # Compute inclusion probabilities + probabilities = (gamma > threshold).mean(dim="sample").to_array() + gamma_mean = gamma.mean(dim="sample").to_array() + selected = probabilities > threshold + + summary = { + "probabilities": probabilities, + "selected": selected, + "gamma_mean": gamma_mean, + } + probs = summary["probabilities"].T + df = pd.DataFrame(index=list(range(len(probs)))) + + df["prob"] = probs + df["selected"] = summary["selected"].T + df["gamma_mean"] = summary["gamma_mean"].T + return df + + def get_shrinkage_factors(self, idata, param_name: str) -> pd.DataFrame: + """ + Extract shrinkage factors from horseshoe prior. + + Only applicable for horseshoe priors. Returns the effective shrinkage + applied to each coefficient: κ_j = τ · λ̃_j + + Parameters + ---------- + idata : arviz.InferenceData + Fitted model inference data + param_name : str + Name of the coefficient parameter + + Returns + ------- + dict + Dictionary with keys: + - 'shrinkage_factors': Array of shrinkage factors per coefficient + - 'tau': Global shrinkage parameter + - 'lambda_tilde': Regularized local shrinkage parameters + + Raises + ------ + ValueError + If prior_type is not 'horseshoe' or required variables not found + + """ + if self.prior_type != "horseshoe": + raise ValueError("Shrinkage factors only available for 'horseshoe' priors") + + import arviz as az + + tau_name = f"tau_{param_name}" + lambda_tilde_name = f"lambda_tilde_{param_name}" + + if tau_name not in idata.posterior: + raise ValueError(f"Could not find '{tau_name}' in posterior") + if lambda_tilde_name not in idata.posterior: + raise ValueError(f"Could not find '{lambda_tilde_name}' in posterior") + + # Extract components + tau = az.extract(idata.posterior[tau_name]).to_array() + lambda_tilde = az.extract(idata.posterior[lambda_tilde_name]).to_array() + + shrinkage_factor = np.array( + [tau[0, i] * lambda_tilde[0, :, :] for i in range(len(tau))] + ) + shrinkage_factor = shrinkage_factor.mean(axis=2) + + summary = { + "shrinkage_factors": shrinkage_factor, + "tau": tau.mean(), + "lambda_tilde": lambda_tilde.mean(dim=("sample")), + } + probs = summary["shrinkage_factors"].T + df = pd.DataFrame(index=list(range(len(probs)))) + df["shrinkage_factor"] = probs + + df["lambda_tilde"] = summary["lambda_tilde"].T + df["tau"] = np.mean(tau).item() + return df + + +def create_variable_selection_prior( + prior_type: str, + name: str, + n_params: int, + dims: str | tuple | None = None, + X: np.ndarray | None = None, + hyperparams: dict[str, Any] | None = None, +) -> pm.Deterministic: + """ + Convenience function to create a variable selection prior in one call. + + This is a shorthand for creating a VariableSelectionPrior instance and + calling create_prior() in one step. + + Parameters + ---------- + prior_type : str + Type of prior: 'spike_and_slab', 'horseshoe', or 'normal' + name : str + Name for the coefficient vector + n_params : int + Number of parameters + dims : str or tuple, optional + Dimension name(s) + X : array-like, optional + Design matrix for data-adaptive hyperparameters + hyperparams : dict, optional + Custom hyperparameters + + Returns + ------- + PyMC variable + The coefficient vector with specified prior + + """ + vs_prior = VariableSelectionPrior(prior_type, hyperparams) + return vs_prior.create_prior(name, n_params, dims, X) diff --git a/docs/source/_static/interrogate_badge.svg b/docs/source/_static/interrogate_badge.svg index c0b839c0..d2d886ad 100644 --- a/docs/source/_static/interrogate_badge.svg +++ b/docs/source/_static/interrogate_badge.svg @@ -1,5 +1,5 @@ - interrogate: 96.1% + interrogate: 95.4% @@ -12,8 +12,8 @@ interrogate interrogate - 96.1% - 96.1% + 95.4% + 95.4% diff --git a/docs/source/notebooks/index.md b/docs/source/notebooks/index.md index c0a9b3ed..fea87975 100644 --- a/docs/source/notebooks/index.md +++ b/docs/source/notebooks/index.md @@ -66,6 +66,7 @@ rkink_pymc.ipynb iv_pymc.ipynb iv_weak_instruments.ipynb +iv_vs_priors.ipynb ::: :::{toctree} diff --git a/docs/source/notebooks/iv_vs_priors.ipynb b/docs/source/notebooks/iv_vs_priors.ipynb new file mode 100644 index 00000000..f01fb219 --- /dev/null +++ b/docs/source/notebooks/iv_vs_priors.ipynb @@ -0,0 +1,2603 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "532c6736", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nathanielforde/mambaforge/envs/CausalPy/lib/python3.13/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": [ + "import arviz as az\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pymc as pm\n", + "\n", + "import causalpy as cp\n", + "\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "b1b3aa75", + "metadata": {}, + "source": [ + "## Variable Selection Priors and Instrumental Variable Designs\n", + "\n", + "When building causal inference models, we face a fundamental dilemma: the bias-variance trade-off. We are tasked with finding the true causal effect of a treatment ($T$) on an outcome ($Y$) while controlling for every single confounder ($X$)—variables that influence both $T$ and $Y$. Include too few variables, and we risk the catastrophic flaw of omitted variable bias (OVB), leading to inaccurate causal claims.Include too many irrelevant variables (noise), and we introduce noise that inflates our uncertainty, widens our posterior intervals, or, worse, creates multicollinearity that destabilizes our estimates.Traditional approaches force us to make hard, upfront decisions about which $X$'s to include. In ideal cases, this is driven by theory. But in the messy reality of data science, where we often have dozens of \"potential\" confounders, how do we make this choice?\n", + "\n", + "We want to let the data help us make these decisions while still maintaining the principled probabilistic framework of Bayesian inference. This is where variable selection priors enter the scene. They allow us to encode our uncertainty about variable relevance directly into the prior, making variable selection part of the inference problem itself, not a separate, error-prone preprocessing step.\n", + "\n", + "Let's first simulate some data with some natural confounding structure and a known true treatment effect of 3.0. We enforce the idea of confounding on the treatment effect with a positive selection probability driving treatment and outcome. The challenge of modelling this data is to tease out the structure of the simultaneous equations in the system. For more details on this Bayesian structural causal modelling [see here](https://causalpy.readthedocs.io/en/latest/knowledgebase/structural_causal_models.html)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "046aa8e0", + "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", + " \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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Y_contY_binT_contT_binalphafeature_0feature_1feature_2feature_3feature_4...feature_19feature_20feature_21feature_22feature_23feature_24Y_cont_scaledY_bin_scaledT_cont_scaledT_bin_scaled
016.8639684.3823565.16053716.1011340.0404540.9530050.366637-0.6144350.556259...0.317673-0.4058860.4482982.4454011.7356750.4782071.4998340.7627451.6762150.997403
1-17.165367-5.402947-3.92080707.0353160.414126-0.599567-0.142998-0.911652-1.164335...-0.5980141.6219861.1634070.2159470.4673590.107958-1.524703-1.768763-1.284772-1.002202
2-6.294315-1.212668-1.69388202.999955-1.2000180.873859-0.083079-0.670225-1.530419...-0.360738-0.446118-0.358958-1.115625-0.8083881.389596-0.558480-0.684716-0.558680-1.002202
34.2731282.7210060.51737406.8014500.320580-0.611745-0.4670160.3583630.715248...-1.888617-2.5892170.051731-0.2905561.2576860.3467840.3807570.3329450.162304-1.002202
4-21.533318-4.793083-5.58007806.8542370.341695-1.022990-0.885820-2.5503340.194493...0.345643-0.634460-0.2979350.896732-0.2303450.966827-1.912927-1.610988-1.825780-1.002202
..................................................................
24955.530940-0.1347291.88855604.055312-0.7778751.191639-0.4393490.3132970.197013...0.031857-0.329209-1.368298-0.3812520.4776270.8182950.492551-0.4058480.609380-1.002202
24960.1912784.124587-1.311103010.2533411.701336-1.1422840.208353-1.1339780.289442...0.4279811.5992960.9138460.5288080.6316440.5487120.0179610.696059-0.433874-1.002202
249714.0708096.2153703.618480110.7036311.881452-0.9739850.908112-1.2431041.122467...-0.893527-1.874865-0.9133281.1941710.5181871.2044331.2515771.2369551.1734250.997403
24982.8880044.6601630.40928015.384630-0.2461480.509868-1.2506350.8227500.241686...0.838648-1.2381710.6119640.145091-0.5046831.6113150.2576470.8346150.1270600.997403
2499-2.2895320.074541-0.78802404.426400-0.6294400.1392250.4573740.0614300.779840...-1.0788421.609967-0.1108430.3267340.428711-0.664431-0.202534-0.351709-0.263323-1.002202
\n", + "

2500 rows × 34 columns

\n", + "
" + ], + "text/plain": [ + " Y_cont Y_bin T_cont T_bin alpha feature_0 feature_1 \\\n", + "0 16.863968 4.382356 5.160537 1 6.101134 0.040454 0.953005 \n", + "1 -17.165367 -5.402947 -3.920807 0 7.035316 0.414126 -0.599567 \n", + "2 -6.294315 -1.212668 -1.693882 0 2.999955 -1.200018 0.873859 \n", + "3 4.273128 2.721006 0.517374 0 6.801450 0.320580 -0.611745 \n", + "4 -21.533318 -4.793083 -5.580078 0 6.854237 0.341695 -1.022990 \n", + "... ... ... ... ... ... ... ... \n", + "2495 5.530940 -0.134729 1.888556 0 4.055312 -0.777875 1.191639 \n", + "2496 0.191278 4.124587 -1.311103 0 10.253341 1.701336 -1.142284 \n", + "2497 14.070809 6.215370 3.618480 1 10.703631 1.881452 -0.973985 \n", + "2498 2.888004 4.660163 0.409280 1 5.384630 -0.246148 0.509868 \n", + "2499 -2.289532 0.074541 -0.788024 0 4.426400 -0.629440 0.139225 \n", + "\n", + " feature_2 feature_3 feature_4 ... feature_19 feature_20 \\\n", + "0 0.366637 -0.614435 0.556259 ... 0.317673 -0.405886 \n", + "1 -0.142998 -0.911652 -1.164335 ... -0.598014 1.621986 \n", + "2 -0.083079 -0.670225 -1.530419 ... -0.360738 -0.446118 \n", + "3 -0.467016 0.358363 0.715248 ... -1.888617 -2.589217 \n", + "4 -0.885820 -2.550334 0.194493 ... 0.345643 -0.634460 \n", + "... ... ... ... ... ... ... \n", + "2495 -0.439349 0.313297 0.197013 ... 0.031857 -0.329209 \n", + "2496 0.208353 -1.133978 0.289442 ... 0.427981 1.599296 \n", + "2497 0.908112 -1.243104 1.122467 ... -0.893527 -1.874865 \n", + "2498 -1.250635 0.822750 0.241686 ... 0.838648 -1.238171 \n", + "2499 0.457374 0.061430 0.779840 ... -1.078842 1.609967 \n", + "\n", + " feature_21 feature_22 feature_23 feature_24 Y_cont_scaled \\\n", + "0 0.448298 2.445401 1.735675 0.478207 1.499834 \n", + "1 1.163407 0.215947 0.467359 0.107958 -1.524703 \n", + "2 -0.358958 -1.115625 -0.808388 1.389596 -0.558480 \n", + "3 0.051731 -0.290556 1.257686 0.346784 0.380757 \n", + "4 -0.297935 0.896732 -0.230345 0.966827 -1.912927 \n", + "... ... ... ... ... ... \n", + "2495 -1.368298 -0.381252 0.477627 0.818295 0.492551 \n", + "2496 0.913846 0.528808 0.631644 0.548712 0.017961 \n", + "2497 -0.913328 1.194171 0.518187 1.204433 1.251577 \n", + "2498 0.611964 0.145091 -0.504683 1.611315 0.257647 \n", + "2499 -0.110843 0.326734 0.428711 -0.664431 -0.202534 \n", + "\n", + " Y_bin_scaled T_cont_scaled T_bin_scaled \n", + "0 0.762745 1.676215 0.997403 \n", + "1 -1.768763 -1.284772 -1.002202 \n", + "2 -0.684716 -0.558680 -1.002202 \n", + "3 0.332945 0.162304 -1.002202 \n", + "4 -1.610988 -1.825780 -1.002202 \n", + "... ... ... ... \n", + "2495 -0.405848 0.609380 -1.002202 \n", + "2496 0.696059 -0.433874 -1.002202 \n", + "2497 1.236955 1.173425 0.997403 \n", + "2498 0.834615 0.127060 0.997403 \n", + "2499 -0.351709 -0.263323 -1.002202 \n", + "\n", + "[2500 rows x 34 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def inv_logit(z):\n", + " \"\"\"Compute the inverse logit (sigmoid) of z.\"\"\"\n", + " return 1 / (1 + np.exp(-z))\n", + "\n", + "\n", + "def simulate_data(n=2500, alpha_true=3.0, rho=0.6, cate_estimation=False, n_zeros=50):\n", + " # Exclusion restrictions:\n", + " # X[0], X[1] affect both Y and T (confounders)\n", + " # X[2], X[3] affect ONLY T (instruments for T)\n", + " # X[4] affects ONLY Y (predictor of Y only)\n", + "\n", + " betaY_core = np.array([0.5, -0.3, 0.0, 0.0, 0.4])\n", + " betaD_core = np.array([0.7, 0.1, -0.4, 0.3, 0.0])\n", + "\n", + " betaY = np.concatenate([betaY_core, np.zeros(n_zeros)])\n", + " betaD = np.concatenate([betaD_core, np.zeros(n_zeros)])\n", + "\n", + " p = len(betaY)\n", + "\n", + " # noise variances and correlation\n", + " sigma_U = 3.0\n", + " sigma_V = 3.0\n", + "\n", + " # design matrix (n × p) with mean-zero columns\n", + " X = np.random.normal(size=(n, p))\n", + " X = (X - X.mean(axis=0)) / X.std(axis=0)\n", + "\n", + " mean = [0, 0]\n", + " cov = [[sigma_U**2, rho * sigma_U * sigma_V], [rho * sigma_U * sigma_V, sigma_V**2]]\n", + " errors = np.random.multivariate_normal(mean, cov, size=n)\n", + " U = errors[:, 0] # error in outcome equation\n", + " V = errors[:, 1] #\n", + "\n", + " # continuous treatment\n", + " T_cont = X @ betaD + V\n", + "\n", + " # latent variable for binary treatment\n", + " T_latent = X @ betaD + V\n", + " T_bin = np.random.binomial(n=1, p=inv_logit(T_latent), size=n)\n", + "\n", + " alpha_individual = 3.0 + 2.5 * X[:, 0]\n", + "\n", + " # outcomes\n", + " Y_cont = alpha_true * T_cont + X @ betaY + U\n", + " if cate_estimation:\n", + " Y_bin = alpha_individual * T_bin + X @ betaY + U\n", + " else:\n", + " Y_bin = alpha_true * T_bin + X @ betaY + U\n", + "\n", + " # combine into DataFrame\n", + " data = pd.DataFrame(\n", + " {\n", + " \"Y_cont\": Y_cont,\n", + " \"Y_bin\": Y_bin,\n", + " \"T_cont\": T_cont,\n", + " \"T_bin\": T_bin,\n", + " }\n", + " )\n", + " data[\"alpha\"] = alpha_true + alpha_individual\n", + " for j in range(p):\n", + " data[f\"feature_{j}\"] = X[:, j]\n", + " data[\"Y_cont_scaled\"] = (data[\"Y_cont\"] - data[\"Y_cont\"].mean()) / data[\n", + " \"Y_cont\"\n", + " ].std(ddof=1)\n", + " data[\"Y_bin_scaled\"] = (data[\"Y_bin\"] - data[\"Y_bin\"].mean()) / data[\"Y_bin\"].std(\n", + " ddof=1\n", + " )\n", + " data[\"T_cont_scaled\"] = (data[\"T_cont\"] - data[\"T_cont\"].mean()) / data[\n", + " \"T_cont\"\n", + " ].std(ddof=1)\n", + " data[\"T_bin_scaled\"] = (data[\"T_bin\"] - data[\"T_bin\"].mean()) / data[\"T_bin\"].std(\n", + " ddof=1\n", + " )\n", + " return data\n", + "\n", + "\n", + "data = simulate_data(n_zeros=20)\n", + "instruments_data = data.copy()\n", + "features = [col for col in data.columns if \"feature\" in col]\n", + "formula = \"Y_cont ~ T_cont + \" + \" + \".join(features)\n", + "instruments_formula = \"T_cont ~ 1 + \" + \" + \".join(features)\n", + "data" + ] + }, + { + "cell_type": "markdown", + "id": "e2472e18", + "metadata": {}, + "source": [ + "CausalPy's `Variable Selection` module provides a way to encode our uncertainty about variable relevance directly into the prior distribution. Rather than choosing which predictors to include, we specify priors that allow coefficients to be shrunk toward zero (or exactly zero) when the data doesn't support their inclusion. The key insight is that variable selection becomes part of the inference problem rather than a preprocessing step. The module offers two fundamentally different approaches to variable selection, each reflecting a different belief about how sparsity manifests in the world. For references to a discussion of variable selection priors we direct the reader to {cite:t}`kaplan_bs_social_science`\n", + "\n", + "#### The Spike-and-Slab: Discrete Choices\n", + "\n", + "Traditional spike-and-slab prior embodies a binary worldview: each variable either matters or it doesn't. Mathematically, we express this as:\n", + "\n", + "$$ \\beta_{j} = \\gamma_{j} \\cdot \\beta_{j_\\text{raw}}$$\n", + "\n", + "such that \n", + "\n", + "$$ \\gamma_{j} \\in \\{0, 1\\}$$\n", + "\n", + "So we have the \"spike\"—the coefficient is exactly zero. When $\\gamma_{j} = 1$, we have the \"slab\" i.e. the coefficient takes on a value from the raw distribution.\n", + "This approach appeals to our intuition about many real-world scenarios. Consider a propensity score model predicting whether someone receives a treatment. Some demographic variables might genuinely have no relationship with treatment assignment, while others are strongly predictive. The spike-and-slab says: let's let each variable clearly declare itself as relevant or irrelevant.\n", + "\n", + "#### The Regularised Horseshoe: Gentle Moderation\n", + "\n", + "The horseshoe prior takes a different philosophical stance. Instead of discrete selection, it says: effects exist on a continuum from negligible to substantial, and we should shrink them proportionally to their signal strength. Small effects get heavily shrunk (possibly to near-zero), while large effects escape shrinkage almost entirely.\n", + "\n", + "$$ \\beta_{j} = \\tau \\cdot \\tilde{\\lambda}_j \\cdot \\beta_{j\\text{raw}}$$\n", + "\n", + "where $\\tau$ is a global shrinkage parameter shared across all coefficients, and $\\tilde{\\lambda}_j$ is local or specific to each coefficient and regularised so as to ensure finite variance. These terms do not have to be zero or one, they reflect a graded weighting. These make it less interpretable than a spike and slab allocation of coefficient weights, but we do not risk pre-maturely zero-ing out weak predictors. \n" + ] + }, + { + "cell_type": "markdown", + "id": "806df6ea", + "metadata": {}, + "source": [ + "### Spike and Slab: Hyperparameters for Variable Selection Priors\n", + "\n", + "You can control the behaviour of the variable selection priors through some of the hyperparameters available. For the spike and slab prior, the most important hyperparamers are `temperature`, `pi_alpha`, and `pi_beta`. \n", + "\n", + "Because our sampler doesn't like discrete variables, we're approximating a bernoulli outcome in our sampling to define the spike and slab. The approximation is governed by the `temperature` parameter. The default value of 0.1 works well in most cases, creating indicators that cluster near 0 or 1 without causing sampling difficulties.\n", + "\n", + "The selection probability parameters `pi_alpha` and `pi_beta` encode your prior belief about sparsity. With both set to 2 (the default), you're placing a Beta(2,2) prior on π, the overall proportion of selected variables. This is symmetric around 0.5 but slightly concentrated there—you're saying \"I don't know how many variables are relevant, but probably not all of them and probably not none of them.\" These hyper-parameters inform the generation of $\\gamma$ which is pulled toward zero or one depending on the hyperparameters. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ae848fe9", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(20, 6))\n", + "axs = axs.flatten()\n", + "axs[0].hist(pm.draw(pm.Beta.dist(2, 2), 1000), ec=\"black\", color=\"slateblue\")\n", + "axs[1].hist(pm.draw(pm.Beta.dist(2, 5), 1000), ec=\"black\", color=\"slateblue\")\n", + "axs[2].hist(pm.draw(pm.Beta.dist(5, 2), 1000), ec=\"black\", color=\"slateblue\")\n", + "axs[1].set_title(r\"Various Distributions for the $\\pi$ hyperparameter\", size=20);" + ] + }, + { + "cell_type": "markdown", + "id": "3237bb49", + "metadata": {}, + "source": [ + "We'll now fit two models and estimate the implied treatment effect. We fit the default IV model and then the same model that uses spike and slab priors on the input variables." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "763ca253", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "Model 1: Normal Priors (No Variable Selection)\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nathanielforde/Documents/Github/CausalPy/causalpy/experiments/instrumental_variable.py:204: UserWarning: Warning. The treatment variable is not Binary.\n", + " We will use the multivariate normal likelihood\n", + " for continuous treatment.\n", + " warnings.warn(\n", + "/Users/nathanielforde/mambaforge/envs/CausalPy/lib/python3.13/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Compiling.. : 0%| | 0/3000 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "clusterinstruments (26)\n", + "\n", + "instruments (26)\n", + "\n", + "\n", + "clustercovariates (27)\n", + "\n", + "covariates (27)\n", + "\n", + "\n", + "cluster3\n", + "\n", + "3\n", + "\n", + "\n", + "cluster2 x 2\n", + "\n", + "2 x 2\n", + "\n", + "\n", + "cluster2\n", + "\n", + "2\n", + "\n", + "\n", + "cluster2500\n", + "\n", + "2500\n", + "\n", + "\n", + "cluster2500 x 2\n", + "\n", + "2500 x 2\n", + "\n", + "\n", + "\n", + "beta_t\n", + "\n", + "beta_t\n", + "~\n", + "Normal\n", + "\n", + "\n", + "\n", + "mu_t\n", + "\n", + "mu_t\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "beta_t->mu_t\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "beta_z\n", + "\n", + "beta_z\n", + "~\n", + "Normal\n", + "\n", + "\n", + "\n", + "mu_y\n", + "\n", + "mu_y\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "beta_z->mu_y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "chol_cov\n", + "\n", + "chol_cov\n", + "~\n", + "_LKJCholeskyCov\n", + "\n", + "\n", + "\n", + "cov\n", + "\n", + "cov\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "chol_cov->cov\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "chol_cov_corr\n", + "\n", + "chol_cov_corr\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "chol_cov->chol_cov_corr\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "chol_cov_stds\n", + "\n", + "chol_cov_stds\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "chol_cov->chol_cov_stds\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "likelihood\n", + "\n", + "likelihood\n", + "~\n", + "Multivariate_normal\n", + "\n", + "\n", + "\n", + "chol_cov->likelihood\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu\n", + "\n", + "mu\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "mu_t->mu\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu_y->mu\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu->likelihood\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pm.model_to_graphviz(result_normal.model)" + ] + }, + { + "cell_type": "markdown", + "id": "34f3a1b7", + "metadata": {}, + "source": [ + "Now compare the structure of the spike and slab model. As before we're fitting a joint model of treatment and outcome. But now we specify hierarchical priors over the beta coefficients to \"select\" the variables of real importance. In the IV case this is particularly interesting because it helps mitigate the risk of over-parameterisation with weak instruments. In effect the sparsity priors act like a \"instrument discovery\" mechanism when used in this joint modelling context. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4f8c2685", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "clusterinstruments (26)\n", + "\n", + "instruments (26)\n", + "\n", + "\n", + "clustercovariates (27)\n", + "\n", + "covariates (27)\n", + "\n", + "\n", + "cluster3\n", + "\n", + "3\n", + "\n", + "\n", + "cluster2 x 2\n", + "\n", + "2 x 2\n", + "\n", + "\n", + "cluster2\n", + "\n", + "2\n", + "\n", + "\n", + "cluster2500\n", + "\n", + "2500\n", + "\n", + "\n", + "cluster2500 x 2\n", + "\n", + "2500 x 2\n", + "\n", + "\n", + "\n", + "pi_beta_t\n", + "\n", + "pi_beta_t\n", + "~\n", + "Beta\n", + "\n", + "\n", + "\n", + "gamma_beta_t\n", + "\n", + "gamma_beta_t\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "pi_beta_t->gamma_beta_t\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "pi_beta_z\n", + "\n", + "pi_beta_z\n", + "~\n", + "Beta\n", + "\n", + "\n", + "\n", + "gamma_beta_z\n", + "\n", + "gamma_beta_z\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "pi_beta_z->gamma_beta_z\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "beta_t\n", + "\n", + "beta_t\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "gamma_beta_t->beta_t\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu_t\n", + "\n", + "mu_t\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "beta_t->mu_t\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "gamma_beta_t_u\n", + "\n", + "gamma_beta_t_u\n", + "~\n", + "Uniform\n", + "\n", + "\n", + "\n", + "gamma_beta_t_u->gamma_beta_t\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "beta_t_raw\n", + "\n", + "beta_t_raw\n", + "~\n", + "Normal\n", + "\n", + "\n", + "\n", + "beta_t_raw->beta_t\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "beta_z\n", + "\n", + "beta_z\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "mu_y\n", + "\n", + "mu_y\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "beta_z->mu_y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "beta_z_raw\n", + "\n", + "beta_z_raw\n", + "~\n", + "Normal\n", + "\n", + "\n", + "\n", + "beta_z_raw->beta_z\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "gamma_beta_z_u\n", + "\n", + "gamma_beta_z_u\n", + "~\n", + "Uniform\n", + "\n", + "\n", + "\n", + "gamma_beta_z_u->gamma_beta_z\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "gamma_beta_z->beta_z\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "chol_cov\n", + "\n", + "chol_cov\n", + "~\n", + "_LKJCholeskyCov\n", + "\n", + "\n", + "\n", + "cov\n", + "\n", + "cov\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "chol_cov->cov\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "chol_cov_corr\n", + "\n", + "chol_cov_corr\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "chol_cov->chol_cov_corr\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "chol_cov_stds\n", + "\n", + "chol_cov_stds\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "chol_cov->chol_cov_stds\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "likelihood\n", + "\n", + "likelihood\n", + "~\n", + "Multivariate_normal\n", + "\n", + "\n", + "\n", + "chol_cov->likelihood\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu\n", + "\n", + "mu\n", + "~\n", + "Deterministic\n", + "\n", + "\n", + "\n", + "mu_t->mu\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu_y->mu\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "mu->likelihood\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pm.model_to_graphviz(result_spike_slab.model)" + ] + }, + { + "cell_type": "markdown", + "id": "368660c8", + "metadata": {}, + "source": [ + "Despite seeing some divergences in our spike and slab model, most other sampler health metrics seem healthy" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0755095c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "az.plot_energy(result_spike_slab.idata, figsize=(20, 6));" + ] + }, + { + "cell_type": "markdown", + "id": "5bffd8b6", + "metadata": {}, + "source": [ + "And since we know the true data generating conditions we can also assess the derived posterior treatment estimates. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "838e0726", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(20, 6))\n", + "az.plot_posterior(\n", + " result_normal.idata,\n", + " var_names=[\"beta_z\"],\n", + " coords={\"covariates\": [\"T_cont\"]},\n", + " ax=ax,\n", + " label=\"Normal\",\n", + ")\n", + "az.plot_posterior(\n", + " result_spike_slab.idata,\n", + " var_names=[\"beta_z\"],\n", + " coords={\"covariates\": [\"T_cont\"]},\n", + " ax=ax,\n", + " color=\"green\",\n", + " label=\"spike and slab\",\n", + ")\n", + "ax.axvline(3, color=\"black\", linestyle=\"--\", label=\"True value\");" + ] + }, + { + "cell_type": "markdown", + "id": "057b4f5d", + "metadata": {}, + "source": [ + "This plot suggests that the spike and slab prior was better able to ignore noise in the process and zero in on the true effect. This will not always work but it is a sensible practice to at least sensitivity check difference between the estimates under different prior settings. We can observe how aggressively the spike and slab prior worked to cull unwanted variables from each model by comparing the values on the coefficients across each model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "127888b7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "axs = az.plot_forest(\n", + " [result_spike_slab.idata, result_normal.idata],\n", + " var_names=[\"beta_z\"],\n", + " combined=True,\n", + " model_names=[\"Spike and Slab\", \"Normal\"],\n", + " r_hat=True,\n", + ")\n", + "axs[0].set_title(\"Parameter Comparison Outcome Model \\n Baseline v Spike and Slab\");" + ] + }, + { + "cell_type": "markdown", + "id": "2d6e01dd", + "metadata": {}, + "source": [ + "The parameter estimates are healthy for both models. With the spike and slab being a little bit more aggressive. But differences are more pronounced in the cull of the instruments. " + ] + }, + { + "cell_type": "markdown", + "id": "f09b24bf", + "metadata": {}, + "source": [ + "#### The Treatment Model\n", + "\n", + "Variable selection is applied to both the outcome and the treatment model. In this way we calibrate our parameters to the joint patterns of realisations between these two endogenous variables. The Normal model (with all covariates included) is the baseline, showing the impact of including many irrelevant variables. Its posterior is centered correctly but is generally wider, reflecting the increased uncertainty/variance due to the noise covariates.\n", + "\n", + "The Spike-and-Slab prior performs better here. This suggests it was successful in decisively excluding the noise variables, reducing the model's overall variance." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "acafc928", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "axs = az.plot_forest(\n", + " [result_spike_slab.idata, result_normal.idata],\n", + " var_names=[\"beta_t\"],\n", + " combined=True,\n", + " model_names=[\"Spike and Slab\", \"Normal\"],\n", + " r_hat=True,\n", + ")\n", + "\n", + "axs[0].set_title(\"Parameter Comparison Treatment Model \\n Baseline v Spike and Slab\");" + ] + }, + { + "cell_type": "markdown", + "id": "07f7d95b", + "metadata": {}, + "source": [ + "The spike and slab prior can also output direct inclusion probabilities that can be used for communication regarding which variables were \"selected\" in the process." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f2a0b213", + "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", + " \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", + " \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", + "
probselectedgamma_mean
00.02250False0.027836
11.00000True0.987589
20.66675True0.690207
30.64050True0.674015
40.03800False0.044785
50.05700False0.065583
60.65600True0.692559
70.01325False0.015218
80.00525False0.006931
90.00200False0.003972
100.00400False0.005936
110.00550False0.007275
120.00525False0.006648
130.00700False0.008973
140.01325False0.015868
150.00625False0.007979
160.06150False0.072126
170.01000False0.013383
180.00675False0.008561
190.00650False0.008700
200.00675False0.009016
210.01050False0.012205
220.01875False0.022215
230.00650False0.008177
240.00900False0.011439
250.00650False0.008250
260.00575False0.007574
\n", + "
" + ], + "text/plain": [ + " prob selected gamma_mean\n", + "0 0.02250 False 0.027836\n", + "1 1.00000 True 0.987589\n", + "2 0.66675 True 0.690207\n", + "3 0.64050 True 0.674015\n", + "4 0.03800 False 0.044785\n", + "5 0.05700 False 0.065583\n", + "6 0.65600 True 0.692559\n", + "7 0.01325 False 0.015218\n", + "8 0.00525 False 0.006931\n", + "9 0.00200 False 0.003972\n", + "10 0.00400 False 0.005936\n", + "11 0.00550 False 0.007275\n", + "12 0.00525 False 0.006648\n", + "13 0.00700 False 0.008973\n", + "14 0.01325 False 0.015868\n", + "15 0.00625 False 0.007979\n", + "16 0.06150 False 0.072126\n", + "17 0.01000 False 0.013383\n", + "18 0.00675 False 0.008561\n", + "19 0.00650 False 0.008700\n", + "20 0.00675 False 0.009016\n", + "21 0.01050 False 0.012205\n", + "22 0.01875 False 0.022215\n", + "23 0.00650 False 0.008177\n", + "24 0.00900 False 0.011439\n", + "25 0.00650 False 0.008250\n", + "26 0.00575 False 0.007574" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary = result_spike_slab.model.vs_prior_outcome.get_inclusion_probabilities(\n", + " result_spike_slab.idata, \"beta_z\"\n", + ")\n", + "summary" + ] + }, + { + "cell_type": "markdown", + "id": "38568d27", + "metadata": {}, + "source": [ + "### Horseshoe\n", + "\n", + "The horsehoe prior takes a continuous philosophical stance. Instead of discrete selection, it says: effects exist on a spectrum from negligible to substantial, and we should shrink them proportionally to their signal strength.\n", + "\n", + "It uses a hierarchical structure where the coefficient $\\beta_j$ is determined by a global shrinkage parameter ($\\tau$) and a local shrinkage parameter so that effects get pulled strongly toward zero (but rarely exactly zero) but there is a chance for counterfailing effects on each individual variable. Large effects escape shrinkage almost entirely, as if they are too big for the horseshoe's magnetic pull.This method embraces probabilistic humility. It's less decisive than the spike-and-slab, but it mitigates the risk of completely zeroing out the small, but real, contributions of certain variables — a risk that the spike-and-slab takes.\n", + "\n", + "The key to the implementation is the hierarchical $\\lambda$ component: \n", + "\n", + "$$ \\tilde{\\lambda}_j = \\sqrt{\\frac{c^2 \\lambda_j^2}{c^2 + \\tau^2 \\lambda_j^2}} $$\n", + "\n", + "is composed of individual local shrinkage parameters and $c^2$ is a regularization parameter that prevents over-shrinkage of genuinely large signals. \n", + "\n", + "#### The $\\tau_0$ hyperparameter\n", + "\n", + "Like the `temperature` parameter in the spike and slab model, the $\\tau_0$ parameter determines the overall level of sparsity expected in the model. However, the $tau_0$ will by default be derived from the data and the number of covariates in your data. While both the horseshoe and spike-and-slab priors address variable selection and sparsity, they embody fundamentally different philosophies about how to achieve these goals. The horseshoe embraces continuity, creating a smooth gradient of shrinkage where all coefficients remain in the model but are pulled toward zero with varying intensity. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "16bb5f90", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(20, 6))\n", + "axs = axs.flatten()\n", + "axs[0].hist(\n", + " pm.draw(pm.InverseGamma.dist(2, 2), 1000) ** 2,\n", + " ec=\"black\",\n", + " color=\"slateblue\",\n", + " bins=30,\n", + ")\n", + "axs[1].hist(\n", + " pm.draw(pm.InverseGamma.dist(3, 3), 1000) ** 2,\n", + " ec=\"black\",\n", + " color=\"slateblue\",\n", + " bins=30,\n", + ")\n", + "axs[2].hist(\n", + " pm.draw(pm.InverseGamma.dist(4, 4), 1000) ** 2,\n", + " ec=\"black\",\n", + " color=\"slateblue\",\n", + " bins=30,\n", + ")\n", + "axs[1].set_title(r\"Various Distributions for the $c^{2}$ hyperparameter\", size=20);" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "63edfa4e", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "Model 3: Horseshoe Priors\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/nathanielforde/Documents/Github/CausalPy/causalpy/experiments/instrumental_variable.py:204: UserWarning: Warning. The treatment variable is not Binary.\n", + " We will use the multivariate normal likelihood\n", + " for continuous treatment.\n", + " warnings.warn(\n", + "/Users/nathanielforde/Documents/Github/CausalPy/causalpy/pymc_models.py:723: UserWarning: Variable selection priors specified. The 'mus' and 'sigmas' in the priors dict will be ignored for beta coefficients. Only 'eta' and 'lkj_sd' will be used.\n", + " warnings.warn(\n", + "Compiling.. : 0%| | 0/3000 [00:00\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", + " \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", + " \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", + "
shrinkage_factorlambda_tildetau
00.0438742.3284680.016754
12.245092119.1514450.016754
20.68014936.0968250.016754
30.60213231.9563270.016754
40.0803904.2664630.016754
50.1068345.6698850.016754
60.64906334.4470350.016754
70.0297811.5805110.016754
80.0282201.4976740.016754
90.0282271.4980500.016754
100.0279641.4840830.016754
110.0269901.4323980.016754
120.0271551.4411490.016754
130.0274311.4558060.016754
140.0317831.6868020.016754
150.0282141.4973610.016754
160.0651933.4598990.016754
170.0353031.8736240.016754
180.0289281.5352710.016754
190.0316751.6810790.016754
200.0314611.6697100.016754
210.0313981.6663690.016754
220.0429322.2784980.016754
230.0303491.6107040.016754
240.0347131.8423120.016754
250.0277611.4733130.016754
260.0287441.5254790.016754
\n", + "" + ], + "text/plain": [ + " shrinkage_factor lambda_tilde tau\n", + "0 0.043874 2.328468 0.016754\n", + "1 2.245092 119.151445 0.016754\n", + "2 0.680149 36.096825 0.016754\n", + "3 0.602132 31.956327 0.016754\n", + "4 0.080390 4.266463 0.016754\n", + "5 0.106834 5.669885 0.016754\n", + "6 0.649063 34.447035 0.016754\n", + "7 0.029781 1.580511 0.016754\n", + "8 0.028220 1.497674 0.016754\n", + "9 0.028227 1.498050 0.016754\n", + "10 0.027964 1.484083 0.016754\n", + "11 0.026990 1.432398 0.016754\n", + "12 0.027155 1.441149 0.016754\n", + "13 0.027431 1.455806 0.016754\n", + "14 0.031783 1.686802 0.016754\n", + "15 0.028214 1.497361 0.016754\n", + "16 0.065193 3.459899 0.016754\n", + "17 0.035303 1.873624 0.016754\n", + "18 0.028928 1.535271 0.016754\n", + "19 0.031675 1.681079 0.016754\n", + "20 0.031461 1.669710 0.016754\n", + "21 0.031398 1.666369 0.016754\n", + "22 0.042932 2.278498 0.016754\n", + "23 0.030349 1.610704 0.016754\n", + "24 0.034713 1.842312 0.016754\n", + "25 0.027761 1.473313 0.016754\n", + "26 0.028744 1.525479 0.016754" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "summary = result_horseshoe.model.vs_prior_outcome.get_shrinkage_factors(\n", + " result_horseshoe.idata, \"beta_z\"\n", + ")\n", + "summary" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "82b0121c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(20, 6))\n", + "az.plot_posterior(\n", + " result_normal.idata, var_names=[\"beta_z\"], coords={\"covariates\": [\"T_cont\"]}, ax=ax\n", + ")\n", + "az.plot_posterior(\n", + " result_horseshoe.idata,\n", + " var_names=[\"beta_z\"],\n", + " coords={\"covariates\": [\"T_cont\"]},\n", + " ax=ax,\n", + " color=\"green\",\n", + ")\n", + "ax.axvline(3, color=\"black\", linestyle=\"--\");" + ] + }, + { + "cell_type": "markdown", + "id": "e15d4f1e", + "metadata": {}, + "source": [ + "In this case it seems the horseshoe prior leads a bi-modal posterior estimate of the treatment effect suggesting a kind of indecision about the level of sparsity to apply. " + ] + }, + { + "cell_type": "markdown", + "id": "fc265f5d", + "metadata": {}, + "source": [ + "### Binary Treatment Case\n", + "\n", + "Our data generating function output two different simulation scenarios, where the treatment was either continuous or binary. This allows us to demonstrate the joint modelling of the binary treatment outcome which uses a Bernoulli likelihood for the treatment variable and latent confounding to model the joint realisation of treatment and outcome. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "89e61d28", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "Model 1: Normal Priors Binary Treatment (No Variable Selection)\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Compiling.. : 0%| | 0/3000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(20, 6))\n", + "az.plot_posterior(\n", + " result_horseshoe_binary.idata,\n", + " var_names=[\"beta_z\"],\n", + " coords={\"covariates\": [\"T_bin\"]},\n", + " ax=ax,\n", + ")\n", + "az.plot_posterior(\n", + " result_normal_binary.idata,\n", + " var_names=[\"beta_z\"],\n", + " coords={\"covariates\": [\"T_bin\"]},\n", + " ax=ax,\n", + " color=\"green\",\n", + ")\n", + "ax.axvline(3, color=\"black\", linestyle=\"--\");" + ] + }, + { + "cell_type": "markdown", + "id": "95027a9c", + "metadata": {}, + "source": [ + "In the Binary case the biases due to weak instruments are overcome by both modelling strategies. " + ] + }, + { + "cell_type": "markdown", + "id": "36ad018b", + "metadata": {}, + "source": [ + "\n", + "### Conclusion: Choosing Your Path Through Uncertainty\n", + "\n", + "Variable selection priors offer a principled way to navigate the tension between model complexity and causal identification. Rather than forcing binary decisions about which variables to include, these priors encode our uncertainty about variable relevance directly into the inferential framework. But as we've seen, the choice between spike-and-slab and horseshoe reflects deeper commitments about how sparsity manifests in the world.\n", + "\n", + "**The spike-and-slab prior** embodies decisiveness. It asks: which variables truly matter? By pushing coefficients toward exactly zero or allowing them to take on substantial values, it produces interpretable inclusion probabilities that clearly communicate which predictors the model has \"selected.\" This approach shines when you believe that many potential confounders are genuine noise—included out of caution but ultimately irrelevant to the causal mechanism. The discrete nature of selection also makes results easier to communicate to stakeholders who think in terms of \"what factors matter?\" \n", + "\n", + "**The horseshoe prior** embraces nuance. It acknowledges that effects exist on a continuum, and that small but real contributions shouldn't be entirely zeroed out. The continuous shrinkage allows weak signals to persist (heavily damped) while strong signals emerge largely unscathed. This is valuable when you suspect that multiple confounders have genuine but varying degrees of influence, and when premature exclusion of any single variable might introduce bias. The regularization parameter $c^2$ acts as a safeguard, preventing even the horseshoe's aggressive shrinkage from overwhelming genuinely large effects.\n", + " \n", + "In our simulations, both approaches identified the true treatment effect of 3, though they arrived there differently. The spike-and-slab showed more confidence, producing tighter posterior intervals by decisively excluding noise variables. The horseshoe's bi-modal posterior in some specifications revealed its uncertainty about the appropriate level of sparsity a kind of probabilistic humility that spike-and-slab's discrete choices don't allow.\n", + "\n", + "#### Practical Guidance\n", + " \n", + "- **Use spike-and-slab when** you have strong priors about sparsity (many potential confounders, few true ones), when interpretability matters (stakeholders want to know \"what's included?\"), or when you're willing to trade some flexibility for more decisive inference.\n", + " \n", + "- **Use horseshoe when** you're uncertain about sparsity levels, when small effects might still matter for causal identification, or when you want the model to smoothly adapt its shrinkage to the data without hard inclusion/exclusion decisions.\n", + " \n", + "- **Use neither when** theory clearly identifies your confounders, when sample size is large relative to the number of predictors, or when the cost of Type I errors (including irrelevant variables) is low relative to Type II errors (excluding true confounders).\n", + " \n", + "#### Final Thoughts\n", + " \n", + "Variable selection priors don't eliminate the need for causal reasoning. They don't tell you which variables are *causally* relevant, only which are *statistically* predictive. But when used thoughtfully—guided by theory about potential confounders, informed by domain knowledge about likely sparsity patterns, and validated through sensitivity analysis. They offer a middle path between the Scylla of over-specification (including everything) and the Charybdis of under-specification (excluding too much). Used within a joint model of treatment and outcome variable, the argument of a variable selection routine represents an attempt to calibrate the parameters to select the instrument structure. What variable selection is really doing in joint treatment-outcome models is calibrating the parameters to discover patterns consistent with instrument structure *if such structure exists in the data*. The horseshoe shrinks away coefficients that appear redundant given the covariance structure between treatment, outcome, and covariates. The spike-and-slab actively excludes variables that don't contribute to explaining either margin after accounting for shared variation.\n", + " \n", + "The ideal use of variable selection in instrumental variable designs is not as a replacement for domain knowledge but as a consistency check. The real power of these methods lies not in automation but in transparency. By making variable selection part of the posterior distribution rather than a pre-processing step, we can quantify and communicate our uncertainty about model structure itself. This moves us closer to the goal of all principled causal inference: not just estimating effects, but understanding the limits of what we can learn from the data we have.\n", + " \n", + "As always in causal inference, the model is a question posed to the data. Variable selection priors help us ask that question more precisely, but we still need theory to tell us if we're asking the right question at all.\n", + "\n" + ] + } + ], + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}