From 057902ba4162fa124d502e4217ce79725e0e8243 Mon Sep 17 00:00:00 2001 From: Eli Date: Thu, 1 Jun 2023 01:10:48 -0400 Subject: [PATCH 1/7] start --- .../counterfactual/handlers/__init__.py | 6 +- .../counterfactual/handlers/ambiguity.py | 4 +- causal_pyro/indexed/handlers.py | 2 +- causal_pyro/indexed/internals.py | 8 +- docs/source/deepscm.ipynb | 582 +++++++----------- 5 files changed, 246 insertions(+), 356 deletions(-) diff --git a/causal_pyro/counterfactual/handlers/__init__.py b/causal_pyro/counterfactual/handlers/__init__.py index 211281f7..befb95c1 100644 --- a/causal_pyro/counterfactual/handlers/__init__.py +++ b/causal_pyro/counterfactual/handlers/__init__.py @@ -49,9 +49,8 @@ def _pyro_gen_intervene_name(cls, msg: Dict[str, Any]) -> None: msg["value"] = name if name is not None else cls.default_name msg["done"] = True - @staticmethod @pyro.poutine.block(hide_types=["intervene"]) - def _pyro_split(msg: Dict[str, Any]) -> None: + def _pyro_split(self, msg: Dict[str, Any]) -> None: if msg["done"]: return @@ -73,9 +72,8 @@ class SingleWorldCounterfactual(BaseCounterfactual): Trivial counterfactual handler that returns the intervened value. """ - @staticmethod @pyro.poutine.block(hide_types=["intervene"]) - def _pyro_split(msg: Dict[str, Any]) -> None: + def _pyro_split(self, msg: Dict[str, Any]) -> None: obs, acts = msg["args"] msg["value"] = intervene(obs, acts[-1], **msg["kwargs"]) msg["done"] = True diff --git a/causal_pyro/counterfactual/handlers/ambiguity.py b/causal_pyro/counterfactual/handlers/ambiguity.py index 1fc7aa74..dbc4650e 100644 --- a/causal_pyro/counterfactual/handlers/ambiguity.py +++ b/causal_pyro/counterfactual/handlers/ambiguity.py @@ -235,7 +235,9 @@ def configure( fn = msg["fn"] while hasattr(fn, "base_dist"): - if isinstance(fn, dist.TransformedDistribution): + if isinstance(fn, dist.FoldedDistribution): + return FactualConditioningReparam() + elif isinstance(fn, dist.TransformedDistribution): return ConditionTransformReparam() else: fn = fn.base_dist diff --git a/causal_pyro/indexed/handlers.py b/causal_pyro/indexed/handlers.py index 7c5c3ced..41616fad 100644 --- a/causal_pyro/indexed/handlers.py +++ b/causal_pyro/indexed/handlers.py @@ -64,7 +64,7 @@ def _pyro_add_indices(self, msg): # are still guaranteed to exit safely in the correct order. self.plates[name] = self._enter_index_plate( _LazyPlateMessenger( - name="__index_plate__" + name, + name=name, dim=self.first_available_dim, size=new_size, ) diff --git a/causal_pyro/indexed/internals.py b/causal_pyro/indexed/internals.py index 7490c66b..3a53c42e 100644 --- a/causal_pyro/indexed/internals.py +++ b/causal_pyro/indexed/internals.py @@ -199,6 +199,12 @@ def _indices_of_distribution( class _LazyPlateMessenger(IndepMessenger): + prefix: str = "__index_plate__" + + def __init__(self, name: str, *args, **kwargs): + self._orig_name: str = name + super().__init__(f"{self.prefix}_{name}", *args, **kwargs) + @property def frame(self) -> CondIndepStackFrame: return CondIndepStackFrame( @@ -208,7 +214,7 @@ def frame(self) -> CondIndepStackFrame: def _process_message(self, msg): if msg["type"] not in ("sample",) or pyro.poutine.util.site_is_subsample(msg): return - if self.frame.name in union( + if self._orig_name in union( indices_of(msg["value"], event_dim=msg["fn"].event_dim), indices_of(msg["fn"]), ): diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index 610d0914..baaf80a0 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -1,51 +1,10 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "# Deep Structural Causal Models Example" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Outline\n", - "\n", - "[Setup](#setup)\n", - "\n", - "[Overview: Counterfacutal estimation with normalizing flows](#overview-counterfactual-estimation-with-normalizing-flows)\n", - "- [Task: Counterfactual Inference](#task-counterfactual-inference)\n", - "- [Challenge: Holding exogeous noise fixed with tractable likelihoods](#challenge-holding-exogenous-noise-fixed-with-tractable-likelihoods)\n", - "- [Assumptions: All confounders observed. Unique mapping from structural functions to joint probability distributions.](#assumptions-all-confounders-observed-unique-mapping-from-structural-functions-to-joint-probability-distributions)\n", - "- [Intuition: Deep invertible neural networks using Normalizing Flows](#intuition-deep-invertible-neural-networks-using-normalizing-flows)\n", - "- [Caveat: Strong assumptions and identifiability](#caveat-strong-assumptions-and-identifiability)\n", - "\n", - "[Example: Morpho-MNIST](#example-morpho-mnist)\n", - "- [Variables](#variables)\n", - "- [Motivation](#motivation)\n", - "\n", - "[Causal Probabilistic Program](#causal-probabilistic-program)\n", - "- [Model Description](#model-description)\n", - "- [Maximum Likelihood Inference](#maximum-likelihood-inference)\n", - "- [Informal Predictive Check: Visualizing Samples](#informal-predictive-check-visualizing-samples)\n", - "\n", - "[Causal Query: counterfactual data generationg](#causal-query-counterfactual-data-generation)\n", - "\n", - "[Results](#results)\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "Here, we install the necessary Pytorch, Pyro, and Causal Pyro dependencies for this example." + "# Example: Deep structural causal model counterfactuals" ] }, { @@ -86,8 +45,11 @@ "import pyro.infer.reparam\n", "import pyro.distributions as dist\n", "\n", + "import causal_pyro\n", + "import causal_pyro.primitives\n", + "import causal_pyro.counterfactual.internals\n", "from causal_pyro.counterfactual.handlers import MultiWorldCounterfactual\n", - "from causal_pyro.interventional.handlers import do\n", + "from causal_pyro.query.do_messenger import do\n", "\n", "pyro.clear_param_store()\n", "pyro.settings.set(module_local_params=True)\n", @@ -95,153 +57,55 @@ ] }, { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview: Counterfactual estimation with normalizing flows\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Task:** Counterfactual inference\n", - "\n", - "With the exception of the [mediation](mediation.ipynb) analysis example, previous examples have focussed on the (conditional) average treatment effects. These estimands answer questions of the form: \"what is the average difference in outcomes for all individuals in the population if they were forced to take treatment $T=1$ relative to if they were forced to take treatment $T=0$. In some settings, however, we are interested in answering retrospective, or \"counterfactual\", questions about individuals. These questions take the form: \"for individual $i$ who's attributes were $X_i$, $T_i$, and $Y_i$, what would $Y_i$ had been if they were forced to take treatment $T_i$ instead?\" This question is different for two reasons: (i) it refers to an individual, rather than a population, and (ii) we are conditioning on what actually happened (i.e. the factual conditions) for that individual. \n", - "\n", - "Methodologically, this means that we'll need to be more careful about all of the external, or \"exogenous\" variables that are often ignored when making causal inferences from data. As a somewhat contrived example, we might ordinarily model the probabilistic causal relationships between random variables representing \"how high I throw my hat in the air\", which we'll call $T$ and \"how far away my hat lands\", which we'll call $Y$, using the following probabilistic relationship.\n", - "\n", - "$$Y_i \\sim uniform(0, 2 * T_i)$$\n", - "\n", - "Here, our uncertainty in how far the hand lands is determined entirely by how windy it is at that time; if no wind is present then the hat will land exactly at our feet and if it's particularly windy the hat twice as many feet away from us as how high we threw it in the air.\n", - "\n", - "In this setting, \"interventional\" questions like those we saw in the [tutorial](tutorial_i.ipynb) can be answered by simply replacing $T_i$ in the above distribution with its intervention assignment, and then sampling from the newly formed distribution. However, when we ask a counterfactual question like; \"given that I threw the hat up 1 foot and it landed at my 0.5 feet away from me, how far away would the hat have landed if I threw it up 2 feet instead?\" we can no longer just sample from the conditional distribution, as this ignores our knowledge of what actually happened factual world. In this case, the answer to the counterfactual question would be that the hat would still land at our feet, because we already know that it wasn't windy.\n", - "\n", - "To answer these kinds of counterfactual questions, causal models must instead be written explicitly in \"structural form\", i.e. collections of deterministic functions of exogenous noise. For example, if we were to make some additional assumptions we could alternatively rewrite our earlier hat throwing model as the following, where $W_i$ describes the amount of windiness:\n", - "\n", - "$$scale = 2$$\n", - "$$W_i \\sim uniform(0, scale)$$\n", - "$$Y_i = W_i * T_i$$\n", - "\n", - "Without belaboring the details, we can answer these kinds of counterfactual questions using a three-step procedure as follows:\n", - "\n", - "1. **Abduction** - Infer the (posterior distribution over) exogenous noise terms given factual observations,\n", - "2. **Action** - Apply an intervention to our causal model, and\n", - "3. **Prediction** - Simulate from our intervened causal model using the inferred exogenous noise terms from 1.\n", - "\n", - "Applying this procedure to our hat-throwing example, we have the following:\n", - "\n", - "1. **Abduction** - $T_i = 1$, $Y_i = 0.5 \\rightarrow W_i = 0.5$\n", - "2. **Action** - $(Y_i|do(T_i = 2)) = W_i * 2$\n", - "3. **Prediction** - $(Y_i|do(T_i=2), W_i=0) = 1$\n", - "\n", - "**Meta Note:** I'm avoidng counterfactual notation here, but maybe it's just more clear to be explicit.\n", - "\n", - "As we'll see later, Causal Pyro combines all three of these steps into a joint inference process using a generalization of what is known as a \"twin-world\" representation for causal inference. In general counterfactual questions do not have fully deterministic answers because; (i) exogenous noise can often not be inferred exactly, and (ii) structural functions themselves may contain uncertainty parameters.\n", - "\n", - "For an excellent overview and discussion of the challenges in answering counterfactual questions, see [@bareinboim2020pearls].\n", - "\n", - "TODO: add citations." - ] - }, - { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "### **Challenge:** Holding exogenous noise fixed with tractable likelihoods\n", - "\n", - "In our simplified example above, we assumed that model parameters (and thus structural functions) were known aprior. In practice this is hardly ever the case, even with the stronger assumptions necessary for answering counterfactual questions. Instead, we would like to learn model parameters within a function class that fit observational data, and then later use those learned parameters to answer counterfactual questions. In particular, we'd like these models to permit a broad class of structural functions, such as Gaussian processes or neural networks.\n", - "\n", - "Unfortunately, one challenge with using these kinds of high-capacity function approximations for counterfactual inference is that they are not often invertible, making it difficult to infer values of exogenous noise for any particular data instance.\n", - "\n", - "In addition, most approximate inference algorithms we'd like to bring to bear for this problem (e.g. MCMC, SVI, etc.) require tractable likelihood evaluations. In our previous example, we could have represented our uncertainty about model parameters by drawing $scale$ from its own prior rather than assume it's known exactly a-priori, e.g. $scale \\sim uniform(0, 3)$. In this case we would want to first approximate a posterior distribution over $scale$ conditional on some collection of observed data $\\{(T_1, Y_i), ..., (T_n, Y_n)\\}$. In this simple setting, we can evaluate the likelihood $p(T, Y|scale)$ using the standard \"change of variables\" formula (see [wikipedia](https://en.wikipedia.org/wiki/Probability_density_function#Function_of_random_variables_and_change_of_variables_in_the_probability_density_function)). In this simple setting we can evaluate the likelihood because the jacobian of our structural function (in this case just a single partial derivative) is tractable. Unfortunately, the vast majority of neural networks do not provide a tractable jacobian." + "## Background: Normalizing flows and counterfactuals\n", + "\n", + "Much of the causal inference literature has focused on relatively simple\n", + "causal models with low dimensional data. In order to perform\n", + "counterfactual reasoning in more complex domains with high dimensional\n", + "data, Palowski et al. [@pawlowski2020deep] introduced *deep structural\n", + "causal models* (Deep SCMs): SCMs with neural networks as the functional\n", + "mechanisms between variables.\n", + "\n", + "Specifically, the neural networks are\n", + "*normalizing flows*. A normalizing flow transforms a base probability\n", + "distribution (often a simple distribution, such as a multivariate\n", + "Gaussian) through a sequence of invertible transformations into a more\n", + "complex distribution (such as a distribution over images). When used\n", + "within a Deep SCM, the flow's base distribution is an exogenous noise\n", + "variable, and its output is an endogenous variable.\n", + "\n", + "A salient property\n", + "of normalizing flows is that computing the likelihood of data can be\n", + "done both exactly and efficiently, and hence training a flow to model a\n", + "data distribution through maximum likelihood is straightforward. In\n", + "addition, the inverse of a normalizing flow can also typically be\n", + "efficiently computed, which renders the abduction step of a\n", + "counterfactual---inferring the posterior over exogenous variables given\n", + "evidence---trivial." ] }, { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Assumptions:** All confounders observed. Unique mapping from structural functions to joint probability distributions.\n", - "\n", - "Like many of the examples thusfar, in this example we will assume that all confounders between endogenous variables are observed. See the [backdoor](backdoor.ipynb) example for a more in-depth description of this assumption.\n", - "\n", - "Additionally, estimating counterfactual quantities requires additional assumptions. Just as many interventional distributions can map to the same observational distribution (see the [tutorial](tutorial.ipynb)), so too can many counterfactual distributions map to the same interventional distribution. Above we chose a single reparameterization of the conditional probability distribution $P(Y_i|T_i)$ in terms of structural functions, but that was just one particular choice, and other choices can often result in different counterfactual conclusions. In general, to disambiguate between multiple plausible structural causal models we must either assume a family structural causal models a priori, either by specifying a parameteric family as we do here, or by making more declarative assumptions about structural functions (e.g. structural functions are monotonic [@pearl2009causality]). Importantly, the use of Normalizing flows as the parametric family in this case is both an innovation **and** an assumption, implicitly restricting the space of structural functions apriori." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Intuition:** Deep invertible neural networks using Normalizing Flows\n", - "\n", - "Much of the causal inference literature has focused on relatively simple causal models with low dimensional data. In order to perform counterfactual reasoning in more complex domains with high dimensional data, Palowski et al. [@pawlowski2020deep] introduced *deep structural causal models* (Deep SCMs): SCMs with neural networks as the functional mechanisms between variables.\n", - "\n", - "Specifically, the neural networks are *normalizing flows*. A normalizing flow transforms a base probability distribution (often a simple distribution, such as a multivariate Gaussian) through a sequence of invertible transformations into a more complex distribution (such as a distribution over images). When used within a Deep SCM, the flow's base distribution is an exogenous noise variable, and its output is an endogenous variable.\n", - "\n", - "A salient property of normalizing flows is that computing the likelihood of data can be done both exactly and efficiently, and hence training a flow to model a data distribution through maximum likelihood is straightforward. In addition, the inverse of a normalizing flow can also typically be efficiently computed, which renders the abduction step of a counterfactual---inferring the posterior over exogenous variables given evidence---trivial." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### **Caveat:** Strong assumptions and identifiability\n", - "\n", - "The authors discuss some possible limitations with using DeepSCMs that we would like to emphasize. Specifically, \"The use of such flexible models also raises questions about the identifiability of the ‘true’ mechanism, as counterfactuals may not be uniquely defined.\" We encourage interested readers to delve deeper into the necessary and sufficient conditions for counterfactual identification, as discussed in [@pearl2009causality, @bareinboim2020pearls]. \n", - "\n", - "In fact, many causal inference researchers dismiss this kind of unit-level counterfactual estimation as entirely implausible (see Rubin's [\"fundamental theorem of causal inference\"](https://en.wikipedia.org/wiki/Rubin_causal_model#:~:text=would%20be%20masked.-,Conclusion,effect%20on%20a%20single%20unit.)).\n", - "\n", - "As computational tool-builders, our goal is only to provide users with the means of deriving causal conclusions from their causal assumptions, regardless of how strong those assumptions may be." - ] - }, - { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Example: Morpho-MNIST\n", "\n", - "In this notebook, we demonstrate the use of \"Deep SCMs\" on a semi-synthetic example derived from the standard MNIST benchmark. Specifically, we use the same dataset that was generated as a part of the empirical evaluation from the Deep SCM paper on which this example is based. In this notebook we filter the dataset to only include images for the digit 5 to reduce the computational overhead of neural network training.\n", - "\n", - "In summary, in constructing this dataset the authors generate synthetic scalar values for \"thickness\" and \"intensity\" and then transform real MNIST images using the image-transformation techniques described in the Morpho-MNIST paper [@castro2019morpho]. See Section 4 in the Deep SCM paper [@pawlowski2020deep] for additional detail." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Variables\n", - "\n", - "This example contains two scalar values on which we can intervene, digit thickness ($T$) and lighting intensity ($I$). The semi-synthetic data was generated acording a known causal structure, in which digit thickness influences lighting intensity, and both influence the final rendered image ($X$). Later we'll assume the same causal structure when constructing the model as a Causal Pyro program.\n", + "We consider a synthetic dataset based on MNIST, where the image of each digit ($X$) depends on stroke thickness ($T$) and brightness ($I$) of the image and the thickness depends on brightness as well.\n", "\n", - "The Morpho-MNIST dataset contains 60,000 transformed MNIST images and digit labels, with corresponding scalar values for digit thickness and lighting intensity for each. After filtering out all images except for the 5s, we are left with 5,421 annotated images." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Motivation\n", - "\n", - "While this specific example is somewhat contrived, it does demonstrate the utility of incorporating neural networks as components of probabilistic causal models, and subsequently reasoning about counterfactual outcomes in high-dimensional non-linear settings. These derived counterfactual outcomes can help provide explanations to experts, such as doctors looking at brain images, and help them to better understand their domain." + "We assume we know full causal structure (i.e., there are no unconfounded variables)." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -284,32 +148,19 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Causal Probabilsitic Program" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Model Description\n", - "\n", - "Just as in our previous examples, here we can encode our causal assumptions as a probabilsitic program in Pyro. Unlike the previous examples, however, in this example we need to be careful to define our model such that each endogenous variable is a deterministic transformation of exogenous noise. Thankfully, Pyro already provides support for defining custom pushforward distributions using `TransformModule`s. This means that later we can (i) tractably condition on endogenous variables using normalizing flows, and (ii) apply interventions on endogenous variables that don't implicitly change exogenous noise.\n", + "## Model: deep structural causal model\n", "\n", - "As the model's implementation is somewhat more involved due to its use of neural network components, we'll start by defining the neural network components in isolation and then later composing them into a causal model. By the end of this section we'll have a Pyro program defining a causal generative model over morphological transformations of MNIST, containing endogenous variables representing the thickness ($T$) and intensity ($I$) of the image, a well as the resulting image itself ($X$).\n", - "\n", - "**Note:** In this example we perform maximum likelihood inference over neural network weights, and thus do not define priors.\n", - "\n", - "First, we define a collection of base classes abstractly representing the transformations from exogenous noise to endogenous variables. Additional detail and background on these transformation modules can be found in the Pyro documentation for `TransformModule`s [here](https://docs.pyro.ai/en/stable/distributions.html?highlight=TransformModule#transformmodule)." + "The following code models morphological transformations of MNIST,\n", + "defining a causal generative model over digits that contains endogenous\n", + "variables to control the width $t$ and intensity $i$ of the stroke:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -380,11 +231,10 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we use these abstractions to construct transformations for each of our two scalar values in the causal model, stroke thickness ($T$) and lighting intensity ($I$). " + "We model stroke thickness with a learnable univariate spline transformation of a standard normal distribution (defined later):" ] }, { @@ -400,8 +250,22 @@ " dist.transforms.Spline(thickness_size, bound=1.),\n", " dist.transforms.AffineTransform(loc=bias, scale=weight),\n", " dist.transforms.biject_to(dist.constraints.positive),\n", - " ])\n", - "\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use a similar approach to model the *conditional* distribution of stroke intensity *given* stroke thickness. The parameters of the univariate spline transformation are not left free, but are themselves a learnable function of thickness. We parameterize this second learnable function with a small multilayer perceptron:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ "class IntensityTransform(ConditionalComposeTransformModule):\n", " def __init__(\n", " self,\n", @@ -438,17 +302,34 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "tags": [] + }, "source": [ - "The transformation for the images is somewhat involved. Much of the neural network architecture is taken from [this PyTorch tutorial](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial11/NF_image_modeling.html) on normalizing flows, which readers are encouraged to peruse for further background on normalizing flows in general and this architecture in particular." + "The transformation for the images is somewhat more involved. We will define it in two parts: an expressive unconditional transformation and a smaller conditional transformation, both of which are themselves composed of repeated blocks of autoregressive normalizing flows. Unlike the transforms for thickness and intensity, which were defined as maps from gaussian noise to data, our image transformation will be defined in the reverse direction, as a mapping from data to noise; the causal probabilistic program we write later on will define a distribution on images using the inverse of our definition here.\n", + "\n", + "Much of the neural network architecture in the first, unconditional transformation is taken from this excellent PyTorch tutorial on generative modelling of images with normalizing flows, which readers are encouraged to peruse for further background on normalizing flows in general and this architecture in particular. The only significant difference between the definitions of the unconditional image transform and its components in this notebook and the PyTorch tutorial above is that this notebook implements a `torch.distributions.Transform` interface for `MaskedAffineCouplingLayer`, making it fully compatible with Pyro models and inference algorithms. The code has also been tweaked to improve compatibility with Pyro's (ab)use of broadcasting in PyTorch." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "class DequantizationTransform(ComposeTransformModule):\n", + " def __init__(self, alpha: float = 1e-5):\n", + " layers = [\n", + " dist.transforms.IndependentTransform(\n", + " dist.transforms.ComposeTransform([\n", + " dist.transforms.AffineTransform(0., 1. / 256),\n", + " dist.transforms.AffineTransform(alpha, (1 - alpha)),\n", + " dist.transforms.SigmoidTransform().inv,\n", + " ]), 3)\n", + " ]\n", + " super().__init__(layers)\n", + "\n", + "\n", "class ConcatELU(torch.nn.Module):\n", " \"\"\"\n", " Activation function that applies ELU in both direction (inverted and plain).\n", @@ -536,7 +417,7 @@ " return self.nn(x)\n", "\n", "\n", - "class MaskedAffineCoupling(dist.torch_transform.TransformModule):\n", + "class MaskedAffineCouplingLayer(dist.torch_transform.TransformModule):\n", " bijective = True\n", " domain = dist.constraints.independent(dist.constraints.real, 3)\n", " codomain = dist.constraints.independent(dist.constraints.real, 3)\n", @@ -587,7 +468,7 @@ " return (x + t) * torch.exp(s)\n", "\n", "\n", - "class ImageTransform(ConditionalComposeTransformModule):\n", + "class UnconditionalImageTransform(ComposeTransformModule):\n", " def __init__(\n", " self,\n", " im_size: int,\n", @@ -598,11 +479,8 @@ " layers_per_block: int,\n", " hidden_channels: int,\n", " *,\n", - " num_cond_blocks: int = 1,\n", - " alpha: float = 1e-5,\n", - " bn_momentum: float = 0.05,\n", + " alpha: float = 1e-5\n", " ln_momentum: float = 1e-5,\n", - " nonlinearity = torch.nn.ReLU(),\n", " ):\n", " self.im_size = im_size\n", " self.input_channels = input_channels\n", @@ -610,26 +488,14 @@ " self.num_blocks = num_blocks\n", " self.layers_per_block = layers_per_block\n", " \n", - " self.num_cond_blocks = num_cond_blocks\n", - " \n", - " self.flat_input_size = input_channels * im_size * im_size\n", - " \n", " layers = []\n", - "\n", + " \n", " # dequantization\n", - " layers += [\n", - " dist.transforms.IndependentTransform(\n", - " dist.transforms.ComposeTransform([\n", - " dist.transforms.AffineTransform(0., 1. / 256),\n", - " dist.transforms.AffineTransform(alpha, (1 - alpha)),\n", - " dist.transforms.SigmoidTransform().inv,\n", - " ]), 3)\n", - " ]\n", + " layers += [DequantizationTransform(alpha=alpha)]\n", " \n", - " # image flow with convolutional blocks\n", " for i in range(num_blocks):\n", " layers += [\n", - " MaskedAffineCoupling(\n", + " MaskedAffineCouplingLayer(\n", " GatedConvNet(input_channels, hidden_channels, layers_per_block, eps=ln_momentum),\n", " self.create_checkerboard_mask(im_size, im_size, invert=(i%2==1)),\n", " input_channels,\n", @@ -638,7 +504,48 @@ " ),\n", " ]\n", " \n", - " # conditioning on context\n", + " super().__init__(layers)\n", + "\n", + " @staticmethod\n", + " def create_checkerboard_mask(h: int, w: int, invert=False):\n", + " x, y = torch.arange(h, dtype=torch.int32), torch.arange(w, dtype=torch.int32)\n", + " xx, yy = torch.meshgrid(x, y, indexing='ij')\n", + " mask = torch.fmod(xx + yy, 2).to(torch.float32).view(1, 1, h, w)\n", + " return mask if not invert else (1. - mask) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The unconditional generative flow above is compact and expressive enough to learn a high-quality approximation to the high-dimensional data distribution. However, to represent conditional distributions over images, we must compose it with a second transformation that is conditionally invertible given an arbitrary context vector.\n", + "\n", + "Pyro comes with a number of conditional transforms that are suitable for this task. In this example, we will use a series of `ConditionalAffineAutoRegressive` transforms because of their relative simplicity, speed, and stability during training. Detailed explanations of their internals are beyond the scope of this notebook; readers seeking more background information about these transformations should consult the Pyro documentation and source code for `ConditionalAffineAutoRegressive`, `ConditionalAutoRegressiveNN` and related functionality." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class ConditionalImageTransform(ConditionalComposeTransformModule):\n", + " def __init__(\n", + " self,\n", + " im_size: int,\n", + " input_channels: int,\n", + " thickness_size: int,\n", + " intensity_size: int,\n", + " num_cond_blocks: int,\n", + " *,\n", + " nonlinearity = torch.nn.ReLU(),\n", + " ):\n", + " self.im_size = im_size\n", + " self.input_channels = input_channels\n", + " self.num_cond_blocks = num_cond_blocks\n", + " self.flat_input_size = input_channels * im_size * im_size\n", + " \n", + " layers = []\n", " layers += [dist.transforms.ReshapeTransform((input_channels, im_size, im_size), (self.flat_input_size,))]\n", " for i in range(self.num_cond_blocks):\n", " layers += [\n", @@ -653,15 +560,72 @@ " ),\n", " ] \n", " layers += [dist.transforms.ReshapeTransform((self.flat_input_size,), (input_channels, im_size, im_size))]\n", + " super().__init__(layers)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Having defined `UnconditionalImageTransform` and `ConditionalImageTransform`, we can compose them into the full conditionally invertible transformation we will be using in our causal model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class ImageTransform(ConditionalComposeTransformModule):\n", + " def __init__(\n", + " self,\n", + " im_size: int,\n", + " input_channels: int,\n", + " thickness_size: int,\n", + " intensity_size: int,\n", + " num_blocks: int,\n", + " layers_per_block: int,\n", + " hidden_channels: int,\n", + " *,\n", + " num_cond_blocks: int = 1,\n", + " alpha: float = 1e-5,\n", + " ln_momentum: float = 1e-5,\n", + " nonlinearity = torch.nn.ReLU(),\n", + " ):\n", + " self.im_size = im_size\n", + " self.input_channels = input_channels\n", + " self.hidden_channels = hidden_channels\n", + " self.num_blocks = num_blocks\n", + " self.layers_per_block = layers_per_block\n", + " self.num_cond_blocks = num_cond_blocks\n", + " self.flat_input_size = input_channels * im_size * im_size\n", " \n", - " super().__init__(layers)\n", + " layers = []\n", + "\n", + " # unconditional image flow: dequantization followed by convolutional blocks\n", + " layers += [UnconditionalImageTransform(\n", + " im_size=im_size,\n", + " input_channels=input_channels,\n", + " thickness_size=thickness_size,\n", + " intensity_size=intensity_size,\n", + " num_blocks=num_blocks,\n", + " layers_per_block=layers_per_block,\n", + " hidden_channels=hidden_channels,\n", + " alpha=alpha,\n", + " ln_momentum=ln_momentum,\n", + " )]\n", " \n", - " @staticmethod\n", - " def create_checkerboard_mask(h: int, w: int, invert=False):\n", - " x, y = torch.arange(h, dtype=torch.int32), torch.arange(w, dtype=torch.int32)\n", - " xx, yy = torch.meshgrid(x, y, indexing='ij')\n", - " mask = torch.fmod(xx + yy, 2).to(torch.float32).view(1, 1, h, w)\n", - " return mask if not invert else (1. - mask)" + " # conditioning on context with conditional autoregressive flows\n", + " layers += [ConditionalImageTransform(\n", + " im_size=im_size,\n", + " input_channels=input_channels,\n", + " thickness_size=thickness_size,\n", + " intensity_size=intensity_size,\n", + " num_cond_blocks=num_cond_blocks,\n", + " nonlinearity=nonlinearity,\n", + " )]\n", + " \n", + " super().__init__(layers)" ] }, { @@ -838,38 +802,12 @@ " layers_per_block=3,\n", " hidden_channels=16,\n", " nonlinearity=torch.nn.ELU(),\n", - ")\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This implementation is significantly more involved than previous examples, as we're now defining causal models with neural networks. However, after defining the neural-network transformations, the resulting causal relationships between variables is remarkably simple. We can see this in the rendering of the causal probabilsitic program below." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ + ")\n", "\n", "model = DeepSCM(thickness_transform, intensity_transform, image_transform)\n", "pyro.render_model(model, render_distributions=True)" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Maximum Likelihood Inference\n", - "\n", - "Next, we can implement a `ConditionedDeepSCM` that wraps our original `DeepSCM` model in a `pyro.plate` and a `pyro.condition` context, representing the fact that we observe a collection of annotated images. " - ] - }, { "cell_type": "code", "execution_count": 7, @@ -965,14 +903,6 @@ "pyro.render_model(conditioned_model, model_args=(thickness[:2], intensity[:2], images[:2]), render_distributions=True)" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Similar to the [CEVAE](cevae.ipynb) tutorial, first we'll update our neural network weights using maximum likelihood inference over the full conditioned dataset, and then later perform our causal inferences by conditioning on a subset of variables. The following code uses a custom implementation of SVI using `pytorch_lightning`. TODO: explain in a sentence why we do this vs. Pyro's original SVI." - ] - }, { "cell_type": "code", "execution_count": 8, @@ -1042,16 +972,6 @@ " trainer.fit(model=lightning_svi, train_dataloaders=dataloader)" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Informal Predictive Check: Visualizing Samples\n", - "\n", - "Before we move on to counterfactual inference, let's first inspect how well our model and inference represent the generative process over MNIST images. Similar to other examples, we can perform an informal assessment by simply generating samples from our model with learned neural network parameters, inspecting the resulting samples qualitatively." - ] - }, { "cell_type": "code", "execution_count": 9, @@ -1059,7 +979,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1069,7 +989,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1080,23 +1000,8 @@ ], "source": [ "predictive = pyro.infer.Predictive(model, guide=lambda *args: None, num_samples=1000, parallel=True).to(device=torch.device(\"cpu\"))\n", - "samples = predictive()\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First let's look at the marginal distributions of stroke thickness and light intensity for MNIST images from our dataset and generated from our model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ + "samples = predictive()\n", + "\n", "fig = plt.figure()\n", "fig.add_subplot(1, 2, 1)\n", "plt.hist(thickness[..., 0], bins=50, alpha=0.5, density=True, label=\"observed\")\n", @@ -1104,28 +1009,12 @@ "plt.title(\"Thickness\")\n", "plt.legend()\n", "\n", - "\n", "fig.add_subplot(1, 2, 2)\n", "plt.hist(intensity[..., 0], bins=50, alpha=0.5, density=True, label=\"observed\")\n", "plt.hist(samples[\"I\"][..., 0].squeeze(), bins=50, alpha=0.5, density=True, label=\"sampled\")\n", "plt.title(\"Intensity\")\n", - "plt.legend()" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we can take a look at a small collection of individual images samples from our model. We can clearly see that our model has learned to generate reasonable looking images for the number 5." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ + "plt.legend()\n", + "\n", "fig = plt.figure()\n", "plt.title(\"Images\")\n", "plt.axis(\"off\")\n", @@ -1136,24 +1025,25 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Causal Query: counterfactual data generation\n", - "\n", - "Now that we've defined our deep SCM model and trained the neural network parameters on observed data, we can start asking interesting causal questions. Specifically, we are interested in the *counterfactual* question: \"given an observed digit $X$, what would the digit have been had $t$ been $t + 1$?\" As we discussed earlier, this question about changes to a specific instance (here a single image) is different from the more typical questions about changes across a population of instances.\n", - "\n", - "One approach for answering these kinds of counterfactual quantities is to use Pearl's three step approach [@pearl2011algorithmization] we discussed earlier:\n", - "\n", - "1. **Abduction** - Infer the (posterior distribution over) exogenous noise terms given factual observations,\n", - "2. **Action** - Apply an intervention to our causal model, and\n", - "3. **Prediction** - Simulate from our intervened causal model using the inferred exogenous noise terms from 1.\n", - "\n", - "However, we can equivalently represent this process with inference in a single, expanded probabilistic program containing two copies of every deterministic statement (a so-called \\\"twin network\\\" representation of counterfactuals, first described in Chapter 7 of [@pearl2009causality] and extended to the PPL setting in [@tavares_2020]). In previous examples and tutorials these twin worlds shared only causal model parameters, but in this case the twin worlds also share exogenous noise terms, enabling unit-level counterfactual reasoning. In a future tutorial we will elaborate on how and why models using `TransformedDistribution`s share noise across counterfactual worlds, and how this differs from all other examples and tutorials.\n", - "\n", - "**Note:** In the case of deterministic structural causal models, as in this model, the abduction step reduces to inverting the neural network function.\n", - "\n" + "## Query: counterfactual data generation\n", + "\n", + "Next we ask a *counterfactual* question: given an observed digit $X$, what\n", + "would the digit have been had $t$ been $t + 1$?\n", + "\n", + "To compute this quantity we would normally:\n", + " 1. invert the model to find latent exogenous noise $u$\n", + " 2. construct an intervened model\n", + " 3. re-simulate the forward model on the $u$ [@pearl2011algorithmization]. \n", + "\n", + "However, we can equivalently\n", + "represent this process with inference in a single, expanded\n", + "probabilistic program containing two copies of every deterministic\n", + "statement (a so-called \\\"twin network\\\" representation of\n", + "counterfactuals, first described in Chapter 7 of [@pearl] and extended\n", + "to the PPL setting in [@tavares_2020])" ] }, { @@ -1265,43 +1155,30 @@ " \n", " def forward(self, x_obs: torch.Tensor, i_act: Optional[torch.Tensor], t_act: Optional[torch.Tensor]):\n", " assert i_act is not None or t_act is not None\n", - " with MultiWorldCounterfactual(first_available_dim=-2), \\\n", + " with MultiWorldCounterfactual(), \\\n", " pyro.plate(\"observations\", size=x_obs.shape[0], dim=-1), \\\n", " do(actions={\"I\": i_act}) if i_act is not None else contextlib.nullcontext(), \\\n", " do(actions={\"T\": t_act}) if t_act is not None else contextlib.nullcontext(), \\\n", " pyro.condition(data={\"X\": x_obs}):\n", - " return self.model()\n", + " return gather(self.model(), IndexSet(I=1, T=1), event_dim=3)\n", "\n", "cf_model = CounterfactualDeepSCM(model)\n", "pyro.render_model(cf_model, model_args=(images[:1], intensity[:1], None))" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Results" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now that we have a transformed causal model representing answers to our counterfactual query, we can sample from it to generate samples from our counterfactual distribution. \n", - "\n", - "**Note:** The process of inverting the normalizing flow networks happens automatically inside the ... \n", - "\n", - "TODO: Eli, could you say more about this note that I started. I'm actually not totally sure where the exogenous noise terms are computed and then propagated forward. I think it is worth touching on a little bit, as a lot of the computation is obscured behind the transformations in this part of the example." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "TODO: Eli, can you pick up here. I'm not following the difference between these two image sets, nor the rows vs. columns." + "Like all counterfactuals, this estimand is not identified in general\n", + "without further assumptions: learning parameters $\\theta$ that match\n", + "observed data does not guarantee that the counterfactual distribution\n", + "will match that of the true causal model. \n", + "\n", + "However, as discussed in the\n", + "original paper [@pawlowski2020deep] in the context of modeling MRI\n", + "images, there are a number of valid practical reasons one might wish to\n", + "compute it anyway, such as explanation or expert evaluation." ] }, { @@ -1311,7 +1188,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1357,7 +1234,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1395,6 +1272,13 @@ " plt.imshow(cf_samples.mean(0)[1].squeeze())\n", " plt.axis(\"off\")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1413,7 +1297,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.10.9" }, "vscode": { "interpreter": { @@ -1422,5 +1306,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 368a47a9dab34cc47259a1c27b7d50b580ae10cd Mon Sep 17 00:00:00 2001 From: Eli Date: Thu, 1 Jun 2023 01:19:30 -0400 Subject: [PATCH 2/7] update code --- docs/source/deepscm.ipynb | 53 ++++++--------------------------------- 1 file changed, 8 insertions(+), 45 deletions(-) diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index baaf80a0..2185ff9c 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -21,7 +21,6 @@ } ], "source": [ - "%reload_ext tensorboard\n", "%reload_ext autoreload\n", "%autoreload 2\n", "%pdb off\n", @@ -45,11 +44,9 @@ "import pyro.infer.reparam\n", "import pyro.distributions as dist\n", "\n", - "import causal_pyro\n", - "import causal_pyro.primitives\n", - "import causal_pyro.counterfactual.internals\n", "from causal_pyro.counterfactual.handlers import MultiWorldCounterfactual\n", - "from causal_pyro.query.do_messenger import do\n", + "from causal_pyro.indexed.ops import IndexSet, gather, indices_of\n", + "from causal_pyro.interventional.handlers import do\n", "\n", "pyro.clear_param_store()\n", "pyro.settings.set(module_local_params=True)\n", @@ -193,41 +190,7 @@ " def __init__(self, transforms: List[dist.transforms.Transform]):\n", " super().__init__([\n", " ConstantParamTransformModule(t) if not isinstance(t, torch.nn.Module) else t for t in transforms\n", - " ])\n", - " \n", - "\n", - "class InverseConditionalTransformModule(dist.conditional.ConditionalTransformModule):\n", - " \n", - " def __init__(self, transform: dist.conditional.ConditionalTransform):\n", - " super().__init__()\n", - " self._transform = transform\n", - " \n", - " @property\n", - " def inv(self) -> dist.conditional.ConditionalTransform:\n", - " return self._transform\n", - " \n", - " def condition(self, context: torch.Tensor):\n", - " return self._transform.condition(context).inv\n", - "\n", - "\n", - "class ConditionalComposeTransformModule(dist.conditional.ConditionalTransformModule):\n", - " def __init__(self, transforms: List):\n", - " self.transforms = [\n", - " dist.conditional.ConstantConditionalTransform(t)\n", - " if not isinstance(t, dist.conditional.ConditionalTransform)\n", - " else t\n", - " for t in transforms\n", - " ]\n", - " super().__init__()\n", - " # for parameter storage... TODO is this necessary?\n", - " self._transforms_module = torch.nn.ModuleList([t for t in transforms if isinstance(t, torch.nn.Module)])\n", - " \n", - " @property\n", - " def inv(self):\n", - " return InverseConditionalTransformModule(self)\n", - "\n", - " def condition(self, context: torch.Tensor):\n", - " return ComposeTransformModule([t.condition(context) for t in self.transforms]).with_cache(1)" + " ])" ] }, { @@ -266,7 +229,7 @@ "metadata": {}, "outputs": [], "source": [ - "class IntensityTransform(ConditionalComposeTransformModule):\n", + "class IntensityTransform(dist.conditional.ConditionalComposeTransformModule):\n", " def __init__(\n", " self,\n", " intensity_size: int,\n", @@ -529,7 +492,7 @@ "metadata": {}, "outputs": [], "source": [ - "class ConditionalImageTransform(ConditionalComposeTransformModule):\n", + "class ConditionalImageTransform(dist.conditional.ConditionalComposeTransformModule):\n", " def __init__(\n", " self,\n", " im_size: int,\n", @@ -576,7 +539,7 @@ "metadata": {}, "outputs": [], "source": [ - "class ImageTransform(ConditionalComposeTransformModule):\n", + "class ImageTransform(dist.conditional.ConditionalComposeTransformModule):\n", " def __init__(\n", " self,\n", " im_size: int,\n", @@ -1160,7 +1123,7 @@ " do(actions={\"I\": i_act}) if i_act is not None else contextlib.nullcontext(), \\\n", " do(actions={\"T\": t_act}) if t_act is not None else contextlib.nullcontext(), \\\n", " pyro.condition(data={\"X\": x_obs}):\n", - " return gather(self.model(), IndexSet(I=1, T=1), event_dim=3)\n", + " return gather(self.model(), IndexSet(I={1}, T={1}), event_dim=3)\n", "\n", "cf_model = CounterfactualDeepSCM(model)\n", "pyro.render_model(cf_model, model_args=(images[:1], intensity[:1], None))" From 982c16a2287a61fe61da246b4c97d3916d6a6b40 Mon Sep 17 00:00:00 2001 From: eb8680 Date: Wed, 5 Jul 2023 11:06:42 -0400 Subject: [PATCH 3/7] refs merge --- docs/source/deepscm.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index 2b19cc07..248e0af7 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -102,7 +102,6 @@ "\n", "For an excellent overview and discussion of the challenges in answering counterfactual questions, see Bareinboim et al.'s (2022) work.\n", "\n", - "TODO: add citations." ] }, { @@ -1235,7 +1234,7 @@ "will match that of the true causal model. \n", "\n", "However, as discussed in the\n", - "original paper [@pawlowski2020deep] in the context of modeling MRI\n", + "original paper [Pawlowski et al. (2020)] in the context of modeling MRI\n", "images, there are a number of valid practical reasons one might wish to\n", "compute it anyway, such as explanation or expert evaluation." ] From ba5c9bff9e6bbfa8f79aa8342ad4399ff5ffe843 Mon Sep 17 00:00:00 2001 From: eb8680 Date: Wed, 5 Jul 2023 11:08:56 -0400 Subject: [PATCH 4/7] fix json --- docs/source/deepscm.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index 248e0af7..37c3781f 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -100,8 +100,7 @@ "\n", "As we'll see later, Causal Pyro combines all three of these steps into a joint inference process using a generalization of what is known as a \"twin-world\" representation for causal inference. In general counterfactual questions do not have fully deterministic answers because; (i) exogenous noise can often not be inferred exactly, and (ii) structural functions themselves may contain uncertainty parameters.\n", "\n", - "For an excellent overview and discussion of the challenges in answering counterfactual questions, see Bareinboim et al.'s (2022) work.\n", - "\n", + "For an excellent overview and discussion of the challenges in answering counterfactual questions, see Bareinboim et al.'s (2022) work.\n" ] }, { From 8eac772d27e469e4a6a7353690d2e15192a7c477 Mon Sep 17 00:00:00 2001 From: Andy Zane Date: Wed, 5 Jul 2023 15:40:29 -0400 Subject: [PATCH 5/7] grammatical fixes, re-applying these changes as the original branch got conflated with something in stash --- docs/source/deepscm.ipynb | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index 37c3781f..ce1f2b30 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -68,15 +68,15 @@ "source": [ "### **Task:** Counterfactual inference\n", "\n", - "With the exception of the [mediation](mediation.ipynb) analysis example, previous examples have focussed on the (conditional) average treatment effects. These estimands answer questions of the form: \"what is the average difference in outcomes for all individuals in the population if they were forced to take treatment $T=1$ relative to if they were forced to take treatment $T=0$. In some settings, however, we are interested in answering retrospective, or \"counterfactual\", questions about individuals. These questions take the form: \"for individual $i$ who's attributes were $X_i$, $T_i$, and $Y_i$, what would $Y_i$ had been if they were forced to take treatment $T_i$ instead?\" This question is different for two reasons: (i) it refers to an individual, rather than a population, and (ii) we are conditioning on what actually happened (i.e. the factual conditions) for that individual. \n", + "With the exception of the [mediation](mediation.ipynb) analysis example, previous examples have focussed on the (conditional) average treatment effects. These estimands answer questions of the form: \"what is the average difference in outcomes for all individuals in the population if they were forced to take treatment $T=1$ relative to if they were forced to take treatment $T=0$. In some settings, however, we are interested in answering retrospective, or \"counterfactual\", questions about individuals. These questions take the form: \"for individual $i$ who's attributes were $X_i$, $T_i$, and $Y_i$, what would $Y_i$ have been if they were forced to take treatment $T_i$ instead?\" This question is different for two reasons: (i) it refers to an individual, rather than a population, and (ii) we are conditioning on what actually happened (i.e. the factual conditions) for that individual.\n", "\n", "Methodologically, this means that we'll need to be more careful about all of the external, or \"exogenous\" variables that are often ignored when making causal inferences from data. As a somewhat contrived example, we might ordinarily model the probabilistic causal relationships between random variables representing \"how high I throw my hat in the air\", which we'll call $T$ and \"how far away my hat lands\", which we'll call $Y$, using the following probabilistic relationship.\n", "\n", "$$Y_i \\sim uniform(0, 2 * T_i)$$\n", "\n", - "Here, our uncertainty in how far the hand lands is determined entirely by how windy it is at that time; if no wind is present then the hat will land exactly at our feet and if it's particularly windy the hat twice as many feet away from us as how high we threw it in the air.\n", + "Here, our uncertainty in how far the hat lands is determined entirely by how windy it is at that time; if no wind is present then the hat will land exactly at our feet and if it's particularly windy the hat will land twice as many feet away from us as how high we threw it in the air.\n", "\n", - "In this setting, \"interventional\" questions like those we saw in the [tutorial](tutorial_i.ipynb) can be answered by simply replacing $T_i$ in the above distribution with its intervention assignment, and then sampling from the newly formed distribution. However, when we ask a counterfactual question like; \"given that I threw the hat up 1 foot and it landed at my 0.5 feet away from me, how far away would the hat have landed if I threw it up 2 feet instead?\" we can no longer just sample from the conditional distribution, as this ignores our knowledge of what actually happened factual world. In this case, the answer to the counterfactual question would be that the hat would still land at our feet, because we already know that it wasn't windy.\n", + "In this setting, \"interventional\" questions like those we saw in the [tutorial](tutorial_i.ipynb) can be answered by simply replacing $T_i$ in the above distribution with its intervention assignment, and then sampling from the newly formed distribution. However, when we ask a counterfactual question — for example, \"given that I threw the hat up 1 foot and it landed at my feet, 0.5 feet away from me, how far away would the hat have landed if I threw it up 2 feet instead?\" — we can no longer just sample from the interventional distribution, as this ignores our knowledge of what actually happened in the factual world. In this case, the answer to the counterfactual question would be that the hat would still land at our feet, because we already know that it wasn't windy.\n", "\n", "To answer these kinds of counterfactual questions, causal models must instead be written explicitly in \"structural form\", i.e. collections of deterministic functions of exogenous noise. For example, if we were to make some additional assumptions we could alternatively rewrite our earlier hat throwing model as the following, where $W_i$ describes the amount of windiness:\n", "\n", @@ -96,9 +96,9 @@ "2. **Action** - $(Y_i|do(T_i = 2)) = W_i * 2$\n", "3. **Prediction** - $(Y_i|do(T_i=2), W_i=0) = 1$\n", "\n", - "**Meta Note:** I'm avoidng counterfactual notation here, but maybe it's just more clear to be explicit.\n", + "\n", "\n", - "As we'll see later, Causal Pyro combines all three of these steps into a joint inference process using a generalization of what is known as a \"twin-world\" representation for causal inference. In general counterfactual questions do not have fully deterministic answers because; (i) exogenous noise can often not be inferred exactly, and (ii) structural functions themselves may contain uncertainty parameters.\n", + "As we'll see later, Causal Pyro combines all three of these steps into a joint inference process using a generalization of what is known as a \"twin-world\" representation for causal inference. In general, counterfactual questions do not have fully deterministic answers because; (i) exogenous noise can often not be inferred exactly, and (ii) structural functions themselves may contain uncertainty parameters.\n", "\n", "For an excellent overview and discussion of the challenges in answering counterfactual questions, see Bareinboim et al.'s (2022) work.\n" ] @@ -110,7 +110,7 @@ "source": [ "### **Challenge:** Holding exogenous noise fixed with tractable likelihoods\n", "\n", - "In our simplified example above, we assumed that model parameters (and thus structural functions) were known aprior. In practice this is hardly ever the case, even with the stronger assumptions necessary for answering counterfactual questions. Instead, we would like to learn model parameters within a function class that fit observational data, and then later use those learned parameters to answer counterfactual questions. In particular, we'd like these models to permit a broad class of structural functions, such as Gaussian processes or neural networks.\n", + "In our simplified example above, we assumed that model parameters (and thus structural functions) were known aprior. In practice this is hardly ever the case, even with the stronger assumptions necessary for answering counterfactual questions. Instead, we would like to learn model parameters within a function class that fits observational data, and then later use those learned parameters to answer counterfactual questions. In particular, we'd like these models to permit a broad class of structural functions, such as Gaussian processes or neural networks.\n", "\n", "Unfortunately, one challenge with using these kinds of high-capacity function approximations for counterfactual inference is that they are not often invertible, making it difficult to infer values of exogenous noise for any particular data instance.\n", "\n", @@ -124,9 +124,9 @@ "source": [ "### **Assumptions:** All confounders observed. Unique mapping from structural functions to joint probability distributions.\n", "\n", - "Like many of the examples thusfar, in this example we will assume that all confounders between endogenous variables are observed. See the [backdoor](backdoor.ipynb) example for a more in-depth description of this assumption.\n", + "Like many of the examples thus far, in this example we will assume that all confounders between endogenous variables are observed. See the [backdoor](backdoor.ipynb) example for a more in-depth description of this assumption.\n", "\n", - "Additionally, estimating counterfactual quantities requires additional assumptions. Just as many interventional distributions can map to the same observational distribution (see the [tutorial](tutorial.ipynb)), so too can many counterfactual distributions map to the same interventional distribution. Above we chose a single reparameterization of the conditional probability distribution $P(Y_i|T_i)$ in terms of structural functions, but that was just one particular choice, and other choices can often result in different counterfactual conclusions. In general, to disambiguate between multiple plausible structural causal models we must either assume a family structural causal models a priori, either by specifying a parameteric family as we do here, or by making more declarative assumptions about structural functions (e.g. structural functions are monotonic \\[Pearl 2009\\]). Importantly, the use of Normalizing flows as the parametric family in this case is both an innovation **and** an assumption, implicitly restricting the space of structural functions apriori." + "Additionally, estimating counterfactual quantities requires additional assumptions. Just as many interventional distributions can map to the same observational distribution (see the [tutorial](tutorial.ipynb)), so too can many counterfactual distributions map to the same interventional distribution. Above we chose a single reparameterization of the conditional probability distribution $P(Y_i|T_i)$ in terms of structural functions, but that was just one particular choice, and other choices can often result in different counterfactual conclusions. In general, to disambiguate between multiple plausible structural causal models we must either assume a family structural causal models a priori, either by specifying a parameteric family as we do here, or by making more declarative assumptions about structural functions (e.g. structural functions are monotonic \\[Pearl 2009\\]). Importantly, the use of Normalizing flows as the parametric family in this case is both an innovation **and** an assumption, implicitly restricting the space of structural functions a priori." ] }, { @@ -154,7 +154,7 @@ "\n", "In fact, many causal inference researchers dismiss this kind of unit-level counterfactual estimation as entirely implausible (see Rubin's [\"fundamental theorem of causal inference\"](https://en.wikipedia.org/wiki/Rubin_causal_model#:~:text=would%20be%20masked.-,Conclusion,effect%20on%20a%20single%20unit.)).\n", "\n", - "As computational tool-builders, our goal is only to provide users with the means of deriving causal conclusions from their causal assumptions, regardless of how strong those assumptions may be." + "As builders of computational tools, our goal is only to provide users with the means of deriving causal conclusions from their causal assumptions, regardless of how strong those assumptions may be." ] }, { @@ -166,7 +166,7 @@ "\n", "We consider a synthetic dataset based on MNIST, where the image of each digit ($X$) depends on stroke thickness ($T$) and brightness ($I$) of the image and the thickness depends on brightness as well.\n", "\n", - "In summary, in constructing this dataset the authors generate synthetic scalar values for \"thickness\" and \"intensity\" and then transform real MNIST images using the image-transformation techniques described in the Morpho-MNIST paper \\[Castro et al. 2019\\]. See Section 4 in the Deep SCM paper \\[Pawlowski et al. 2020\\] for additional detail." + "In constructing this dataset, the authors generate synthetic scalar values for \"thickness\" and \"intensity\" and then transform real MNIST images using the image-transformation techniques described in the Morpho-MNIST paper \\[Castro et al. 2019\\]. See Section 4 in the Deep SCM paper \\[Pawlowski et al. 2020\\] for additional detail." ] }, { @@ -191,6 +191,17 @@ "While this specific example is somewhat contrived, it does demonstrate the utility of incorporating neural networks as components of probabilistic causal models, and subsequently reasoning about counterfactual outcomes in high-dimensional non-linear settings. These derived counterfactual outcomes can help provide explanations to experts, such as doctors looking at brain images, and help them to better understand their domain." ] }, + { + "cell_type": "markdown", + "source": [ + "### Dataset\n", + "\n", + "Here, we load and process the dataset as described thus far. The raw data is available here, at the Morpho-MNIST [repository](https://github.com/dccastro/Morpho-MNIST#datasets).\n" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 2, From 37563112a3fc641519848234842e8ab6983b780f Mon Sep 17 00:00:00 2001 From: Eli Date: Thu, 6 Jul 2023 03:32:14 -0400 Subject: [PATCH 6/7] add plot description --- docs/source/deepscm.ipynb | 71 +++++++++++++++++++++++++++++---------- 1 file changed, 53 insertions(+), 18 deletions(-) diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index ce1f2b30..3fb5e059 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -192,15 +193,16 @@ ] }, { + "attachments": {}, "cell_type": "markdown", + "metadata": { + "collapsed": false + }, "source": [ "### Dataset\n", "\n", "Here, we load and process the dataset as described thus far. The raw data is available here, at the Morpho-MNIST [repository](https://github.com/dccastro/Morpho-MNIST#datasets).\n" - ], - "metadata": { - "collapsed": false - } + ] }, { "cell_type": "code", @@ -209,7 +211,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -252,6 +254,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -301,6 +304,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -324,6 +328,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -371,6 +376,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": { "tags": [] @@ -585,6 +591,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -634,6 +641,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -699,6 +707,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1049,7 +1058,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1059,7 +1068,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1095,6 +1104,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1235,18 +1245,26 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Like all counterfactuals, this estimand is not identified in general\n", + "Counterfactuals cannot be identified from observational data in general\n", "without further assumptions: learning parameters $\\theta$ that match\n", "observed data does not guarantee that the counterfactual distribution\n", - "will match that of the true causal model. \n", - "\n", - "However, as discussed in the\n", + "will match that of the true causal model. However, as discussed in e.g. the\n", "original paper [Pawlowski et al. (2020)] in the context of modeling MRI\n", "images, there are a number of valid practical reasons one might wish to\n", - "compute it anyway, such as explanation or expert evaluation." + "compute counterfactuals with a model anyway, such as explanation or expert evaluation.\n", + "\n", + "It just so happens that the data generating process for our images of handwritten digits has enough additional structure (specifically, one-dimensional covariates with monotonic mechanisms) that recovering approximations of the causal mechanisms from observational data may not be impossible in theory.\n", + "In the following pair of plots, we experimentally interrogate our trained model's causal knowledge by visualizing counterfactual images sampled from the model.\n", + "\n", + "The leftmost entry of each row is an image from the training dataset, followed by several counterfactual sample images drawn from the model given the original image and an intervention on one of the two covariates, with the other covariate held fixed at its observed value.\n", + "\n", + "The intervened values (intensity in the first plot, thickness in the second) for the samples in each row are monotonically increasing from left to right, starting from their ground truth observed values for the training image in that row. Successive samples in a row are shown alongside their pixelwise differences with their neighbors.\n", + "\n", + "In the first plot below, we can see stroke intensity increasing monotonically from left to right while the stroke thickness remains roughly constant." ] }, { @@ -1256,7 +1274,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1295,6 +1313,14 @@ " plt.axis(\"off\")" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the second plot, we can see the images' stroke thickness increasing monotonically from left to right in each row, while their stroke intensity remains roughly constant." + ] + }, { "cell_type": "code", "execution_count": 15, @@ -1302,7 +1328,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1342,7 +1368,19 @@ ] }, { + "attachments": {}, "cell_type": "markdown", + "metadata": {}, + "source": [ + "These qualitative results suggest that our deep generative model has indeed managed to approximately disentangle and recover the causal mechanisms of stroke thickness and intensity." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, "source": [ "## References\n", "\n", @@ -1359,10 +1397,7 @@ "Tavares, Zenna, James Koppel, Xin Zhang, and Armando Solar-Lezama. “A Language for Counterfactual Generative Models.” MIT Technical Report, 2020. http://www.jameskoppel.com/publication/omega/.\n", "\n", "\n" - ], - "metadata": { - "collapsed": false - } + ] } ], "metadata": { From b6d8dac09e339b7cc8451efe0ce5167fc24f3756 Mon Sep 17 00:00:00 2001 From: Andy Zane Date: Thu, 6 Jul 2023 11:47:17 -0400 Subject: [PATCH 7/7] adds link to referenced pyro tutorial --- docs/source/deepscm.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/deepscm.ipynb b/docs/source/deepscm.ipynb index 3fb5e059..0dfea1b5 100644 --- a/docs/source/deepscm.ipynb +++ b/docs/source/deepscm.ipynb @@ -384,7 +384,7 @@ "source": [ "The transformation for the images is somewhat more involved. We will define it in two parts: an expressive unconditional transformation and a smaller conditional transformation, both of which are themselves composed of repeated blocks of autoregressive normalizing flows. Unlike the transforms for thickness and intensity, which were defined as maps from gaussian noise to data, our image transformation will be defined in the reverse direction, as a mapping from data to noise; the causal probabilistic program we write later on will define a distribution on images using the inverse of our definition here.\n", "\n", - "Much of the neural network architecture in the first, unconditional transformation is taken from this excellent PyTorch tutorial on generative modelling of images with normalizing flows, which readers are encouraged to peruse for further background on normalizing flows in general and this architecture in particular. The only significant difference between the definitions of the unconditional image transform and its components in this notebook and the PyTorch tutorial above is that this notebook implements a `torch.distributions.Transform` interface for `MaskedAffineCouplingLayer`, making it fully compatible with Pyro models and inference algorithms. The code has also been tweaked to improve compatibility with Pyro's (ab)use of broadcasting in PyTorch." + "Much of the neural network architecture in the first, unconditional transformation is taken from [this excellent PyTorch tutorial](https://uvadlc-notebooks.readthedocs.io/en/latest/tutorial_notebooks/tutorial11/NF_image_modeling.html) on generative modelling of images with normalizing flows, which readers are encouraged to peruse for further background on normalizing flows in general and this architecture in particular. The only significant difference between the definitions of the unconditional image transform and its components in this notebook and the PyTorch tutorial above is that this notebook implements a `torch.distributions.Transform` interface for `MaskedAffineCouplingLayer`, making it fully compatible with Pyro models and inference algorithms. The code has also been tweaked to improve compatibility with Pyro's (ab)use of broadcasting in PyTorch." ] }, { @@ -555,7 +555,7 @@ " layers_per_block: int,\n", " hidden_channels: int,\n", " *,\n", - " alpha: float = 1e-5\n", + " alpha: float = 1e-5,\n", " ln_momentum: float = 1e-5,\n", " ):\n", " self.im_size = im_size\n",