From 7fd4469f0f6ac339510fd55eb1461fc20277080b Mon Sep 17 00:00:00 2001 From: Keith Battocchi Date: Thu, 10 Jul 2025 00:05:06 -0400 Subject: [PATCH] pytorch DeepIV WIP Signed-off-by: Keith Battocchi --- .github/workflows/ci.yml | 10 +- README.md | 30 ++ doc/map.svg | 4 + doc/reference.rst | 10 + doc/spec/comparison.rst | 2 + doc/spec/estimation/deepiv.rst | 86 +++++ doc/spec/estimation_iv.rst | 1 + econml/iv/__init__.py | 2 +- econml/iv/nnet/__init__.py | 6 + econml/iv/nnet/_deepiv.py | 467 +++++++++++++++++++++++ econml/tests/test_deepiv.py | 618 +++++++++++++++++++++++++++++++ econml/tests/test_integration.py | 35 ++ notebooks/Deep IV Examples.ipynb | 607 ++++++++++++++++++++++++++++++ pyproject.toml | 4 + 14 files changed, 1876 insertions(+), 6 deletions(-) create mode 100644 doc/spec/estimation/deepiv.rst create mode 100644 econml/iv/nnet/__init__.py create mode 100644 econml/iv/nnet/_deepiv.py create mode 100644 econml/tests/test_deepiv.py create mode 100644 notebooks/Deep IV Examples.ipynb diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 14c31e3db..1b4d467b3 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -118,7 +118,7 @@ jobs: kind: [except-customer-scenarios, customer-scenarios] include: - kind: "except-customer-scenarios" - extras: "[plt,ray]" + extras: "[nn,plt,ray]" pattern: "(?!CustomerScenarios)" install_graphviz: true version: '3.12' @@ -223,16 +223,16 @@ jobs: extras: "" - kind: other opts: '-m "cate_api and not ray" -n auto' - extras: "[plt]" + extras: "[nn,plt]" - kind: dml opts: '-m "dml and not ray"' - extras: "[plt]" + extras: "[nn,plt]" - kind: main opts: '-m "not (notebook or automl or dml or serial or cate_api or treatment_featurization or ray)" -n 2' - extras: "[plt,dowhy]" + extras: "[nn,plt,dowhy]" - kind: treatment opts: '-m "treatment_featurization and not ray" -n auto' - extras: "[plt]" + extras: "[nn,plt]" - kind: ray opts: '-m "ray"' extras: "[ray]" diff --git a/README.md b/README.md index bebc4f614..2168bf39b 100644 --- a/README.md +++ b/README.md @@ -415,6 +415,36 @@ lb, ub = est.effect_interval(X_test, alpha=0.05) # OLS confidence intervals ``` +
+Deep Instrumental Variables (click to expand) + +```Python +import keras +from econml.iv.nnet import DeepIV + +treatment_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(2,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17)]) +response_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(2,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(1)]) +est = DeepIV(n_components=10, # Number of gaussians in the mixture density networks) + m=lambda z, x: treatment_model(keras.layers.concatenate([z, x])), # Treatment model + h=lambda t, x: response_model(keras.layers.concatenate([t, x])), # Response model + n_samples=1 # Number of samples used to estimate the response + ) +est.fit(Y, T, X=X, Z=Z) # Z -> instrumental variables +treatment_effects = est.effect(X_test) +``` +
+ See the References section for more details. ### Interpretability diff --git a/doc/map.svg b/doc/map.svg index bf5e19900..937ab27ee 100644 --- a/doc/map.svg +++ b/doc/map.svg @@ -107,6 +107,10 @@ + + Deep IV + + NonParamDMLIV diff --git a/doc/reference.rst b/doc/reference.rst index e46a67414..f763e82c7 100644 --- a/doc/reference.rst +++ b/doc/reference.rst @@ -86,6 +86,16 @@ Doubly Robust (DR) IV econml.iv.dr.IntentToTreatDRIV econml.iv.dr.LinearIntentToTreatDRIV +.. _deepiv_api: + +DeepIV +^^^^^^ + +.. autosummary:: + :toctree: _autosummary + + econml.iv.nnet.DeepIV + .. _tsls_api: Sieve Methods diff --git a/doc/spec/comparison.rst b/doc/spec/comparison.rst index 7216ef235..7200903fd 100644 --- a/doc/spec/comparison.rst +++ b/doc/spec/comparison.rst @@ -9,6 +9,8 @@ Detailed estimator comparison +=============================================+==============+==============+==================+=============+=================+============+==============+====================+ | :class:`.SieveTSLS` | Any | Yes | | Yes | Assumed | Yes | Yes | | +---------------------------------------------+--------------+--------------+------------------+-------------+-----------------+------------+--------------+--------------------+ +| :class:`.DeepIV` | Any | Yes | | | | Yes | Yes | | ++---------------------------------------------+--------------+--------------+------------------+-------------+-----------------+------------+--------------+--------------------+ | :class:`.SparseLinearDML` | Any | | Yes | Yes | Assumed | Yes | Yes | Yes | +---------------------------------------------+--------------+--------------+------------------+-------------+-----------------+------------+--------------+--------------------+ | :class:`.SparseLinearDRLearner` | Categorical | | Yes | | Projected | | Yes | Yes | diff --git a/doc/spec/estimation/deepiv.rst b/doc/spec/estimation/deepiv.rst new file mode 100644 index 000000000..10d739cff --- /dev/null +++ b/doc/spec/estimation/deepiv.rst @@ -0,0 +1,86 @@ +Deep Instrumental Variables +=========================== + +Instrumental variables (IV) methods are an approach for estimating causal effects despite the presence of confounding latent variables. +The assumptions made are weaker than the unconfoundedness assumption needed in DML. +The cost is that when unconfoundedness holds, IV estimators will be less efficient than DML estimators. +What is required is a vector of instruments :math:`Z`, assumed to casually affect the distribution of the treatment :math:`T`, +and to have no direct causal effect on the expected value of the outcome :math:`Y`. The package offers two IV methods for +estimating heterogeneous treatment effects: deep instrumental variables [Hartford2017]_ +and the two-stage basis expansion approach of [Newey2003]_. + +The setup of the model is as follows: + +.. math:: + + Y = g(T, X, W) + \epsilon + +where :math:`\E[\varepsilon|X,W,Z] = h(X,W)`, so that the expected value of :math:`Y` depends only on :math:`(T,X,W)`. +This is known as the *exclusion restriction*. +We assume that the conditional distribution :math:`F(T|X,W,Z)` varies with :math:`Z`. +This is known as the *relevance condition*. +We want to learn the heterogeneous treatment effects: + +.. math:: + + \tau(\vec{t}_0, \vec{t}_1, \vec{x}) = \E[g(\vec{t}_1,\vec{x},W) - g(\vec{t}_0,\vec{x},W)] + +where the expectation is taken with respect to the conditional distribution of :math:`W|\vec{x}`. +If the function :math:`g` is truly non-parametric, then in the special case where :math:`T`, :math:`Z` and :math:`X` are discrete, +the probability matrix giving the distribution of :math:`T` for each value of :math:`Z` needs to be invertible pointwise at :math:`\vec{x}` +in order for this quantity to be identified for arbitrary :math:`\vec{t}_0` and :math:`\vec{t}_1`. +In practice though we will place some parametric structure on the function :math:`g` which will make learning easier. +In deep IV, this takes the form of assuming :math:`g` is a neural net with a given architecture; in the sieve based approaches, +this amounts to assuming that :math:`g` is a weighted sum of a fixed set of basis functions. [1]_ + +As explained in [Hartford2017]_, the Deep IV module learns the heterogenous causal effects by minimizing the "reduced-form" prediction error: + +.. math:: + + \hat{g}(T,X,W) \equiv \argmin_{g \in \mathcal{G}} \sum_i \left(y_i - \int g(T,x_i,w_i) dF(T|x_i,w_i,z_i)\right)^2 + +where the hypothesis class :math:`\mathcal{G}` are neural nets with a given architecture. +The distribution :math:`F(T|x_i,w_i,z_i)` is unknown and so to make the objective feasible it must be replaced by an estimate +:math:`\hat{F}(T|x_i,w_i,z_i)`. +This estimate is obtained by modeling :math:`F` as a mixture of normal distributions, where the parameters of the mixture model are +the output of a "first-stage" neural net whose inputs are :math:`(x_i,w_i,z_i)`. +Optimization of the "first-stage" neural net is done by stochastic gradient descent on the (mixture-of-normals) likelihood, +while optimization of the "second-stage" model for the treatment effects is done by stochastic gradient descent with +three different options for the loss: + + * Estimating the two integrals that make up the true gradient calculation by independent averages over + mini-batches of data, which are unbiased estimates of the integral. + * Using the modified objective function + + .. math:: + + \sum_i \sum_d \left(y_i - g(t_d,x_i,w_i)\right)^2 + + where :math:`t_d \sim \hat{F}(t|x_i,w_i,z_i)` are draws from the estimated first-stage neural net. This modified + objective function is not guaranteed to lead to consistent estimates of :math:`g`, but has the advantage of requiring + only a single set of samples from the distribution, and can be interpreted as regularizing the loss with a + variance penalty. [2]_ + * Using a single set of samples to compute the gradient of the loss; this will only be an unbiased estimate of the + gradient in the limit as the number of samples goes to infinity. + +Training proceeds by splitting the data into a training and test set, and training is stopped when test set performance +(on the reduced form prediction error) starts to degrade. + +The output is an estimated function :math:`\hat{g}`. To obtain an estimate of :math:`\tau`, we difference the estimated +function at :math:`\vec{t}_1` and :math:`\vec{t}_0`, replacing the expectation with the empirical average over all +observations with the specified :math:`\vec{x}`. + + +.. rubric:: Footnotes + +.. [1] + Asymptotic arguments about non-parametric consistency require that the neural net architecture (respectively set of basis functions) + are allowed to grow at some rate so that arbitrary functions can be approximated, but this will not be our concern here. +.. [2] + .. math:: + + & \int \left(y_i - g(t,x_i,w_i)\right)^2 dt \\ + =~& y_i - 2 y_i \int g(t,x_i,w_i)\,dt + \int g(t,x_i,w_i)^2\,dt \\ + =~& y_i - 2 y_i \int g(t,x_i,w_i)\,dt + \left(\int g(t,x_i,w_i)\,dt\right)^2 + \int g(t,x_i,w_i)^2\,dt - \left(\int g(t,x_i,w_i)\,dt\right)^2 \\ + =~& \left(y_i - \int g(t,x_i,w_i)\,dt\right)^2 + \left(\int g(t,x_i,w_i)^2\,dt - \left(\int g(t,x_i,w_i)\,dt\right)^2\right) \\ + =~& \left(y_i - \int g(t,x_i,w_i)\,dt\right)^2 + \Var_t g(t,x_i,w_i) diff --git a/doc/spec/estimation_iv.rst b/doc/spec/estimation_iv.rst index 03f436861..93b1c82be 100644 --- a/doc/spec/estimation_iv.rst +++ b/doc/spec/estimation_iv.rst @@ -14,5 +14,6 @@ of [Newey2003]_. .. toctree:: :maxdepth: 2 + estimation/deepiv.rst estimation/two_sls.rst estimation/orthoiv.rst \ No newline at end of file diff --git a/econml/iv/__init__.py b/econml/iv/__init__.py index 9ef5066ac..b771315a8 100644 --- a/econml/iv/__init__.py +++ b/econml/iv/__init__.py @@ -1,4 +1,4 @@ # Copyright (c) PyWhy contributors. All rights reserved. # Licensed under the MIT License. -__all__ = ["dml", "dr", "sieve"] +__all__ = ["dml", "dr", "nnet", "sieve"] diff --git a/econml/iv/nnet/__init__.py b/econml/iv/nnet/__init__.py new file mode 100644 index 000000000..9161ac3da --- /dev/null +++ b/econml/iv/nnet/__init__.py @@ -0,0 +1,6 @@ +# Copyright (c) PyWhy contributors. All rights reserved. +# Licensed under the MIT License. + +from ._deepiv import DeepIV, MixtureOfGaussiansModule + +__all__ = ["DeepIV, MixtureOfGaussiansModule"] diff --git a/econml/iv/nnet/_deepiv.py b/econml/iv/nnet/_deepiv.py new file mode 100644 index 000000000..da7ba2224 --- /dev/null +++ b/econml/iv/nnet/_deepiv.py @@ -0,0 +1,467 @@ +# Copyright (c) PyWhy contributors. All rights reserved. +# Licensed under the MIT License. + +"""Deep IV estimator and related components.""" + +import numpy as np +from ..._cate_estimator import BaseCateEstimator +from ...utilities import MissingModule +try: + import torch + import torch.nn as nn + from torch import logsumexp, softmax, exp, log + from torch.distributions import Distribution, Categorical, MultivariateNormal, Normal, Independent + from torch.utils.data import DataLoader, TensorDataset +except ImportError as exn: + torch = nn = Distribution = MissingModule( + "torch and torch.nn are required to use the DeepIV estimator", exn) + +# TODO: make sure to use random seeds wherever necessary +# TODO: make sure that the public API consistently uses "T" instead of "P" for the treatment + + +def _expand_dim(x, n, dim=-1): + """Expand a single dimension by a factor of n.""" + new_size = x.size()[:dim] + (n,) + x.size()[dim:] + return x.unsqueeze(dim).expand(new_size) + + +class MixtureOfGaussians(Distribution): + """ + A mixture of Gaussians model with the specified probabilities, means, and standard deviations. + + Parameters + ---------- + pi : tensor (n_components) + The probabilities of each component + mu : tensor (n_components × d_t) + The means of each component + sig : tensor (n_components, n_components × d_t, or n_components × d_t × d_t) + The standard deviations of each component. If a single tensor is provided, it will be broadcast + to the based on the number of dimensions of the means. If a 2D tensor is provided, it will be + used as a diagonal covariance matrix. If a 3D tensor is provided, it will be + used as a MultivariateNormal covariance matrix. + """ + + @property + def mean(self): + return (self.pi.unsqueeze(-2) @ self.mu).squeeze(-2) + + def __init__(self, pi, mu, sig): + self.pi = pi + self.mu = mu + self.sig = sig + if sig.dim() == mu.dim()-1: + self.sig = sig.unsqueeze(-1).expand(mu.size()) + self.trailing_sig_dim = () + if sig.dim() == mu.dim()+1: + self.trailing_sig_dim = (sig.size()[-1],) + super().__init__(pi.size()[:-1], mu.size()[-1:]) + + def sample(self, sample_shape=torch.Size()): + ind = Categorical(self.pi).sample(sample_shape) + if self.trailing_sig_dim: + samples = MultivariateNormal(self.mu, self.sig).sample(sample_shape) + else: + samples = Independent(Normal(self.mu, self.sig), 1).sample(sample_shape) + + # expand indices to add the dimension of the gaussian + ind = _expand_dim(ind, self.mu.size(-1), len(ind.size())) + + # add the component dimension to the index, so that it's compatible with gather + ind = ind.unsqueeze(-2) + + # use gather to select the samples identified by ind, then squeeze out component dim + return samples.gather(-2, ind).squeeze(-2) + + def log_prob(self, value): + # expand value to add the component dimension + value = value.unsqueeze(-2) + if self.trailing_sig_dim: + norms = MultivariateNormal(self.mu, self.sig).log_prob(value) + else: + norms = Independent(Normal(self.mu, self.sig), 1).log_prob(value) + # log(sum(pi_i * N_i)) = logsumexp(log(pi_i) + log(N_i)), where log(N_i) is the log prob we already have + return logsumexp(log(self.pi) + norms, dim=-1) + + +class MixtureOfGaussiansModule(nn.Module): + def __init__(self, n_components, d_t, d_z, d_x, size_hidden=64): + super().__init__() + self.pi = nn.Sequential(nn.Linear(d_z + d_x, size_hidden), + nn.ReLU(), + nn.Linear(size_hidden, n_components)) + self.mu = nn.Sequential(nn.Linear(d_z + d_x, size_hidden), + nn.ReLU(), + nn.Linear(size_hidden, n_components * d_t), + nn.Unflatten(-1, (n_components, d_t))) + self.sig = nn.Sequential(nn.Linear(d_z + d_x, size_hidden), + nn.ReLU(), + nn.Linear(size_hidden, n_components)) + + def forward(self, z, x): + ft = torch.cat([z, x], dim=-1) + return MixtureOfGaussians(softmax(self.pi(ft), dim=-1), self.mu(ft), exp(self.sig(ft))) + +class DeepIV(BaseCateEstimator): + def __init__(self, model_t, model_y, + batch_size, + n_samples, n_gradient_samples, + optimizer=torch.optim.Adam): + self._model_t = model_t + self._model_y = model_y + self._batch_size = batch_size + self._n_samples = n_samples + self._n_gradient_samples = n_gradient_samples + self._optimizer = optimizer + super().__init__() + + def _fit_impl(self, Y, T, X, Z): + Y, T, X, Z = [torch.from_numpy(a).float() for a in (Y, T, X, Z)] + + b = self._batch_size + + self._model_t.train() + + opt = self._optimizer(self._model_t.parameters()) + for epoch in range(100): + total_loss = 0 + for i in range(0, len(T), b): + opt.zero_grad() + loss = -self._model_t(Z[i:i+b], X[i:i+b]).log_prob(T[i:i+b]).sum() + total_loss += loss.item() + loss.backward() + opt.step() + print(f"Average loss for epoch {epoch+1}: {total_loss / len(T)}") + + self._model_t.eval() + + opt = self._optimizer(self._model_y.parameters()) + for epoch in range(100): + total_loss = 0 + for i in range(0, len(Y), b): + x = _expand_dim(X[i:i+b], self._n_samples, dim=0) + opt.zero_grad() + t_s = self._model_t(Z[i:i+b], X[i:i+b]).sample((self._n_samples,)) + if self._n_gradient_samples > 0: + t_g = self._model_t(Z[i:i+b], X[i:i+b]).sample((self._n_gradient_samples,)) + y_g = self._model_y(t_g, x).mean(dim=0) + with torch.no_grad(): + diff = Y[i:i+b] - self._model_y(t_s, X[i:i+b].expand_as(t_s)).mean(dim=0) + diff_2 = diff + 2 * y_g + loss = (diff * (diff_2 - 2 * y_g)).sum() + else: + y = _expand_dim(Y[i:i+b], self._n_samples, dim=0) + # no separate gradient samples; use the alternative regularizing loss from the DeepIV paper instead + # (take the average outside of the squared difference, rather than average predicted y inside) + loss = ((y - self._model_y(t_s, x)) ** 2).mean(dim=0).sum() + total_loss += loss.item() + loss.backward() + opt.step() + print(f"Average loss for epoch {epoch+1}: {total_loss / len(Y)}") + + self._model_y.eval() + + def effect(self, X=None, T0=0, T1=1): + X, T0, T1 = [torch.from_numpy(a).float() for a in (X, T0, T1)] + if X is None: + X = torch.empty((len(T0), 0)) + return (self._model_y(T1, X) - self._model_y(T0, X)).detach().numpy() + + +class TorchResponseLoss(nn.Module): + """ + Torch module that computes the loss of a response model on data. + + Parameters + ---------- + h : Module (with signature (tensor, tensor) -> tensor) + Method for generating samples of y given samples of t and x + + sample_t : int -> Tensor + Method for getting n samples of t + + x : Tensor + Values of x + + y : Tensor + Values of y + + samples: int + The number of samples to use + + use_upper_bound : bool + Whether to use an upper bound to the true loss + (equivalent to adding a regularization penalty on the variance of h) + + gradient_samples : int + The number of separate additional samples to use when calculating the gradient. + This can only be nonzero if user_upper_bound is False, in which case the gradient of + the returned loss will be an unbiased estimate of the gradient of the true loss. + + """ + + def forward(self, h, sample_t, x, y, samples=50, use_upper_bound=False, gradient_samples=50): + assert not (use_upper_bound and gradient_samples) + + # Note that we assume that there is a single batch dimension, so that we expand x and y along dim=1 + # This is because if x or y is a vector, then expanding along dim=-2 would do the wrong thing + + # generate n samples of t, then take the mean of f(t,x) with that sample and an expanded x + def mean(f, n): + result = torch.mean(f(sample_t(n), _expand(x, n, dim=1)), dim=1) + assert y.size() == result.size() + return result + + if gradient_samples: + # we want to separately sample the gradient; we use detach to treat the sampled model as constant + # the overall computation ensures that we have an interpretable loss (y-h̅(p,x))², + # but also that the gradient is -2(y-h̅(p,x))∇h̅(p,x) with *different* samples used for each average + diff = y - mean(h, samples) + grad = 2 * mean(h, gradient_samples) + return diff.detach() * ((diff + grad).detach() - grad) + elif use_upper_bound: + # mean of (y-h(p,x))² + return mean(lambda t, x: (_expand(y, samples, dim=1) - h(t, x)).pow(2), samples) + else: + return (y - mean(h, samples)).pow(2) + + +class TorchDeepIVEstimator(BaseCateEstimator): + """ + The Deep IV Estimator (see http://proceedings.mlr.press/v70/hartford17a/hartford17a.pdf). + + Parameters + ---------- + n_components : int + Number of components in the mixture density network + + m : Module (signature (tensor, tensor) -> tensor) + Torch module featurizing z and x inputs + + h : Module (signature (tensor, tensor) -> tensor) + Torch module returning y given t and x. This should work on tensors with arbitrary leading dimensions. + + n_samples : int + The number of samples to use + + use_upper_bound_loss : bool, optional + Whether to use an upper bound to the true loss + (equivalent to adding a regularization penalty on the variance of h). + Defaults to False. + + n_gradient_samples : int, optional + The number of separate additional samples to use when calculating the gradient. + This can only be nonzero if user_upper_bound is False, in which case the gradient of + the returned loss will be an unbiased estimate of the gradient of the true loss. + Defaults to 0. + + optimizer : parameters -> Optimizer + The optimizer to use. Defaults to `Adam` + + inference: string, inference method, or None + Method for performing inference. This estimator supports 'bootstrap' + (or an instance of `BootstrapOptions`) + + """ + + def __init__(self, n_components, m, h, + n_samples, use_upper_bound_loss=False, n_gradient_samples=0, + first_stage_batch_size=32, + second_stage_batch_size=32, + first_stage_epochs=2, + second_stage_epochs=2, + optimizer=torch.optim.Adam, + inference=None): + self._n_components = n_components + self._m = m + self._h = h + self._n_samples = n_samples + self._use_upper_bound_loss = use_upper_bound_loss + self._n_gradient_samples = n_gradient_samples + self._first_stage_batch_size = first_stage_batch_size + self._second_stage_batch_size = second_stage_batch_size + self._first_stage_epochs = first_stage_epochs + self._second_stage_epochs = second_stage_epochs + self._optimizer = optimizer + super().__init__(inference=inference) + + def _fit_impl(self, Y, T, X, Z): + """Estimate the counterfactual model from data. + + That is, estimate functions τ(·, ·, ·), ∂τ(·, ·). + + Parameters + ---------- + Y: (n × d_y) matrix or vector of length n + Outcomes for each sample + T: (n × dₜ) matrix or vector of length n + Treatments for each sample + X: optional (n × dₓ) matrix + Features for each sample + Z: optional (n × d_z) matrix + Instruments for each sample + + Returns + ------- + self + + """ + assert 1 <= np.ndim(X) <= 2 + assert 1 <= np.ndim(Z) <= 2 + assert 1 <= np.ndim(T) <= 2 + assert 1 <= np.ndim(Y) <= 2 + assert np.shape(X)[0] == np.shape(Y)[0] == np.shape(T)[0] == np.shape(Z)[0] + # in case vectors were passed for Y or T, keep track of trailing dims for reshaping effect output + + d_x, d_y, d_z, d_t = [np.shape(a)[1:] for a in [X, Y, Z, T]] + self._d_y = d_y + + d_m = self._m(torch.Tensor(np.empty((1,) + d_z)), torch.Tensor(np.empty((1,) + d_x))).size()[1] + + Y, T, X, Z = [torch.from_numpy(A).float() for A in (Y, T, X, Z)] + n_components = self._n_components + + treatment_model = self._m + + class Mog(nn.Module): + def __init__(self): + super().__init__() + self.treatment_model = treatment_model + self.mog_model = MixtureOfGaussians(n_components, d_m, (d_t if d_t else None)) + + def forward(self, z, x): + features = self.treatment_model(z, x) + return self.mog_model(features) + + mog = Mog() + self._mog = mog + mog.train() + opt = self._optimizer(mog.parameters()) + + # train first-stage model + loader = DataLoader(TensorDataset(T, Z, X), shuffle=True, batch_size=self._first_stage_batch_size) + for epoch in range(self._first_stage_epochs): + total_loss = 0 + for i, (t, z, x) in enumerate(loader): + opt.zero_grad() + pi, mu, sig = mog(z, x) + loss = TorchMogLoss()(pi, mu, sig, t).sum() + total_loss += loss.item() + if i % 30 == 0: + print(loss / t.size()[0]) + loss.backward() + opt.step() + print(f"Average loss for epoch {epoch+1}: {total_loss / len(loader.dataset)}") + + mog.eval() # set mog to evaluation mode + for p in mog.parameters(): + p.requires_grad_(False) + + self._h.train() + opt = self._optimizer(self._h.parameters()) + + loader = DataLoader(TensorDataset(Y, Z, X), shuffle=True, batch_size=self._second_stage_batch_size) + for epoch in range(self._second_stage_epochs): + total_loss = 0 + for i, (y, z, x) in enumerate(loader): + opt.zero_grad() + pi, mu, sig = mog(z, x) + loss = TorchResponseLoss()(self._h, + lambda n: TorchMogSampleModel()(n, pi, mu, sig), + x, y, + self._n_samples, self._use_upper_bound_loss, self._n_gradient_samples) + loss = loss.sum() + total_loss += loss.item() + if i % 30 == 0: + print(loss / y.size()[0]) + loss.backward() + opt.step() + print(f"Average loss for epoch {epoch+1}: {total_loss / len(loader.dataset)}") + + self._h.eval() # set h to evaluation mode + for p in self._h.parameters(): + p.requires_grad_(False) + + def effect(self, X=None, T0=0, T1=1): + """ + Calculate the heterogeneous treatment effect τ(·,·,·). + + The effect is calculated between the two treatment points + conditional on a vector of features on a set of m test samples {T0ᵢ, T1ᵢ, Xᵢ}. + + Parameters + ---------- + T0: (m × dₜ) matrix + Base treatments for each sample + T1: (m × dₜ) matrix + Target treatments for each sample + X: optional (m × dₓ) matrix + Features for each sample + + Returns + ------- + τ: (m × d_y) matrix + Heterogeneous treatment effects on each outcome for each sample + Note that when Y is a vector rather than a 2-dimensional array, the corresponding + singleton dimension will be collapsed (so this method will return a vector) + """ + if np.ndim(T0) == 0: + T0 = np.repeat(T0, 1 if X is None else np.shape(X)[0]) + if np.ndim(T1) == 0: + T1 = np.repeat(T1, 1 if X is None else np.shape(X)[0]) + if X is None: + X = np.empty((np.shape(T0)[0], 0)) + return self.predict(T1, X) - self.predict(T0, X) + + def marginal_effect(self, T, X=None): + """ + Calculate the marginal effect ∂τ(·, ·) around a base treatment point conditional on features. + + Parameters + ---------- + T: (m × dₜ) matrix + Base treatments for each sample + X: optional(m × dₓ) matrix + Features for each sample + + Returns + ------- + grad_tau: (m × d_y × dₜ) array + Heterogeneous marginal effects on each outcome for each sample + Note that when Y or T is a vector rather than a 2-dimensional array, + the corresponding singleton dimensions in the output will be collapsed + (e.g. if both are vectors, then the output of this method will also be a vector) + """ + if X is None: + X = np.empty((np.shape(T)[0], 0)) + X, T = [torch.from_numpy(A).float() for A in [X, T]] + if self._d_y: + X, T = [A.unsqueeze(1).expand((-1,) + self._d_y + (-1,)) for A in [X, T]] + T.requires_grad_(True) + if self._d_y: + self._h(T, X).backward(torch.eye(self._d_y[0]).expand(X.size()[0], -1, -1)) + return T.grad.numpy() + else: + self._h(T, X).backward(torch.ones(X.size()[0])) + return T.grad.numpy() + + def predict(self, T, X): + """Predict outcomes given treatment assignments and features. + + Parameters + ---------- + T: (m × dₜ) matrix + Base treatments for each sample + X: (m × dₓ) matrix + Features for each sample + + Returns + ------- + Y: (m × d_y) matrix + Outcomes for each sample + Note that when Y is a vector rather than a 2-dimensional array, the corresponding + singleton dimension will be collapsed (so this method will return a vector) + """ + X, T = [torch.from_numpy(A).float() for A in [X, T]] + return self._h(T, X).numpy().reshape((-1,) + self._d_y) diff --git a/econml/tests/test_deepiv.py b/econml/tests/test_deepiv.py new file mode 100644 index 000000000..264ce5105 --- /dev/null +++ b/econml/tests/test_deepiv.py @@ -0,0 +1,618 @@ +# Copyright (c) PyWhy contributors. All rights reserved. +# Licensed under the MIT License. + +"""Tests for `deepiv` module.""" + +import unittest +import numpy as np +import warnings +from sklearn.preprocessing import OneHotEncoder + +try: + import keras + import keras.backend as K + keras_installed = True +except ImportError: + keras_installed = False + +try: + import torch + torch_installed = True +except ImportError: + torch_installed = False + +import pytest + +from econml.iv.nnet import DeepIV + + +@pytest.mark.skipif(not torch_installed, reason="Torch not installed") +class TestDeepIV(unittest.TestCase): + + def test_mog_module(self): + # ensure that we can fit some different conditional distributions + + # discrete data: points at corners of a rotating square + # if fully learned, average logprob should be log(0.25) = -1.386 + def sample(theta:torch.Tensor): + x = torch.cos(theta) * torch.choice([-1., 1.]) + y = torch.sin(theta) * torch.choice([-1., 1.]) + return torch.stack([x, y], dim=1) + + + + + @pytest.mark.slow + def test_deepiv_shape(self): + fit_opts = {"epochs": 2} + + """Make sure that arbitrary sizes for t, z, x, and y don't break the basic operations.""" + for _ in range(5): + d_t = np.random.choice(range(1, 4)) # number of treatments + d_z = np.random.choice(range(1, 4)) # number of instruments + d_x = np.random.choice(range(1, 4)) # number of features + d_y = np.random.choice(range(1, 4)) # number of responses + n = 500 + # simple DGP only for illustration + x = np.random.uniform(size=(n, d_x)) + z = np.random.uniform(size=(n, d_z)) + p_x_t = np.random.uniform(size=(d_x, d_t)) + p_z_t = np.random.uniform(size=(d_z, d_t)) + t = x @ p_x_t + z @ p_z_t + p_xt_y = np.random.uniform(size=(d_x * d_t, d_y)) + y = (x.reshape(n, -1, 1) * t.reshape(n, 1, -1)).reshape(n, -1) @ p_xt_y + + # Define the treatment model neural network architecture + # This will take the concatenation of one-dimensional values z and x as input, + # so the input shape is (d_z + d_x,) + # The exact shape of the final layer is not critical because the Deep IV framework will + # add extra layers on top for the mixture density network + treatment_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(d_z + d_x,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17)]) + + # Define the response model neural network architecture + # This will take the concatenation of one-dimensional values t and x as input, + # so the input shape is (d_t + d_x,) + # The output should match the shape of y, so it must have shape (d_y,) in this case + # NOTE: For the response model, it is important to define the model *outside* + # of the lambda passed to the DeepIvEstimator, as we do here, + # so that the same weights will be reused in each instantiation + response_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(d_t + d_x,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(d_y)]) + + deepIv = DeepIV(n_components=10, # number of gaussians in our mixture density network + m=lambda z, x: treatment_model( + keras.layers.concatenate([z, x])), # treatment model + h=lambda t, x: response_model(keras.layers.concatenate([t, x])), # response model + n_samples=1, # number of samples to use to estimate the response + use_upper_bound_loss=False, # whether to use an approximation to the true loss + # number of samples to use in second estimate of the response + # (to make loss estimate unbiased) + n_gradient_samples=1, + # Keras optimizer to use for training - see https://keras.io/optimizers/ + optimizer='adam', + first_stage_options=fit_opts, + second_stage_options=fit_opts) + + deepIv.fit(Y=y, T=t, X=x, Z=z) + # do something with predictions... + deepIv.predict(T=t, X=x) + deepIv.effect(x, np.zeros_like(t), t) + + # also test vector t and y + for _ in range(3): + d_z = np.random.choice(range(1, 4)) # number of instruments + d_x = np.random.choice(range(1, 4)) # number of features + n = 500 + # simple DGP only for illustration + x = np.random.uniform(size=(n, d_x)) + z = np.random.uniform(size=(n, d_z)) + p_x_t = np.random.uniform(size=(d_x,)) + p_z_t = np.random.uniform(size=(d_z,)) + t = x @ p_x_t + z @ p_z_t + p_xt_y = np.random.uniform(size=(d_x,)) + y = (x * t.reshape(n, 1)) @ p_xt_y + + # Define the treatment model neural network architecture + # This will take the concatenation of one-dimensional values z and x as input, + # so the input shape is (d_z + d_x,) + # The exact shape of the final layer is not critical because the Deep IV framework will + # add extra layers on top for the mixture density network + treatment_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(d_z + d_x,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17)]) + + # Define the response model neural network architecture + # This will take the concatenation of one-dimensional values t and x as input, + # so the input shape is (d_t + d_x,) + # The output should match the shape of y, so it must have shape (d_y,) in this case + # NOTE: For the response model, it is important to define the model *outside* + # of the lambda passed to the DeepIvEstimator, as we do here, + # so that the same weights will be reused in each instantiation + response_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(1 + d_x,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(1)]) + + deepIv = DeepIV(n_components=10, # number of gaussians in our mixture density network + m=lambda z, x: treatment_model( + keras.layers.concatenate([z, x])), # treatment model + h=lambda t, x: response_model(keras.layers.concatenate([t, x])), # response model + n_samples=1, # number of samples to use to estimate the response + use_upper_bound_loss=False, # whether to use an approximation to the true loss + # number of samples to use in second estimate of the response + # (to make loss estimate unbiased) + n_gradient_samples=1, + # Keras optimizer to use for training - see https://keras.io/optimizers/ + optimizer='adam', + first_stage_options=fit_opts, + second_stage_options=fit_opts) + + deepIv.fit(Y=y, T=t, X=x, Z=z) + # do something with predictions... + deepIv.predict(T=t, X=x) + assert (deepIv.effect(x).shape == (n,)) + + # Doesn't work with CNTK backend as of 2018-07-17 - see https://github.com/keras-team/keras/issues/10715 + + @pytest.mark.slow + def test_deepiv_models(self): + n = 2000 + epochs = 2 + e = np.random.uniform(low=-0.5, high=0.5, size=(n, 1)) + z = np.random.uniform(size=(n, 1)) + x = np.random.uniform(size=(n, 1)) + e + p = x + z * e + np.random.uniform(size=(n, 1)) + y = p * x + e + + losses = [] + marg_effs = [] + + z_fresh = np.random.uniform(size=(n, 1)) + e_fresh = np.random.uniform(low=-0.5, high=0.5, size=(n, 1)) + x_fresh = np.random.uniform(size=(n, 1)) + e_fresh + p_fresh = x_fresh + z_fresh * e_fresh + np.random.uniform(size=(n, 1)) + y_fresh = p_fresh * x_fresh + e_fresh + + for (n1, u, n2) in [(2, False, None), (2, True, None), (1, False, 1)]: + treatment_model = keras.Sequential([keras.layers.Dense(10, activation='relu', input_shape=(2,)), + keras.layers.Dense(10, activation='relu'), + keras.layers.Dense(10, activation='relu')]) + + hmodel = keras.Sequential([keras.layers.Dense(10, activation='relu', input_shape=(2,)), + keras.layers.Dense(10, activation='relu'), + keras.layers.Dense(1)]) + + deepIv = DeepIV(n_components=10, + m=lambda z, x: treatment_model(keras.layers.concatenate([z, x])), + h=lambda t, x: hmodel(keras.layers.concatenate([t, x])), + n_samples=n1, use_upper_bound_loss=u, n_gradient_samples=n2, + first_stage_options={'epochs': epochs}, second_stage_options={'epochs': epochs}) + deepIv.fit(y, p, X=x, Z=z) + + losses.append(np.mean(np.square(y_fresh - deepIv.predict(p_fresh, x_fresh)))) + marg_effs.append(deepIv.marginal_effect(np.array([[0.3], [0.5], [0.7]]), np.array([[0.4], [0.6], [0.2]]))) + print("losses: {}".format(losses)) + print("marg_effs: {}".format(marg_effs)) + + @pytest.mark.slow + def test_deepiv_models_paper(self): + def monte_carlo_error(g_hat, data_fn, ntest=5000, has_latent=False, debug=False): + seed = np.random.randint(1e9) + try: + # test = True ensures we draw test set images + x, z, t, y, g_true = data_fn(ntest, seed, test=True) + except ValueError: + warnings.warn("Too few images, reducing test set size") + ntest = int(ntest * 0.7) + # test = True ensures we draw test set images + x, z, t, y, g_true = data_fn(ntest, seed, test=True) + + # re-draw to get new independent treatment and implied response + t = np.linspace(np.percentile(t, 2.5), np.percentile(t, 97.5), ntest).reshape(-1, 1) + # we need to make sure z _never_ does anything in these g functions (fitted and true) + # above is necesary so that reduced form doesn't win + if has_latent: + x_latent, _, _, _, _ = data_fn(ntest, seed, images=False) + y = g_true(x_latent, z, t) + else: + y = g_true(x, z, t) + y_true = y.flatten() + y_hat = g_hat(x, z, t).flatten() + return ((y_hat - y_true)**2).mean() + + def one_hot(col, **kwargs): + z = col.reshape(-1, 1) + enc = OneHotEncoder(sparse_output=False, **kwargs) + return enc.fit_transform(z) + + def sensf(x): + return 2.0 * ((x - 5)**4 / 600 + np.exp(-((x - 5) / 0.5)**2) + x / 10. - 2) + + def emocoef(emo): + emoc = (emo * np.array([1., 2., 3., 4., 5., 6., 7.])[None, :]).sum(axis=1) + return emoc + + psd = 3.7 + pmu = 17.779 + ysd = 158. # 292. + ymu = -292.1 + + def storeg(x, price): + emoc = emocoef(x[:, 1:]) + time = x[:, 0] + g = sensf(time) * emoc * 10. + (emoc * sensf(time) - 2.0) * (psd * price.flatten() + pmu) + y = (g - ymu) / ysd + return y.reshape(-1, 1) + + def demand(n, seed=1, ynoise=1., pnoise=1., ypcor=0.8, use_images=False, test=False): + rng = np.random.RandomState(seed) + + # covariates: time and emotion + time = rng.rand(n) * 10 + emotion_id = rng.randint(0, 7, size=n) + emotion = one_hot(emotion_id, categories=[np.arange(7)]) + + emotion_feature = emotion + + # random instrument + z = rng.randn(n) + + # z -> price + v = rng.randn(n) * pnoise + price = sensf(time) * (z + 3) + 25. + price = price + v + price = (price - pmu) / psd + + # true observable demand function + x = np.concatenate([time.reshape((-1, 1)), emotion_feature], axis=1) + x_latent = np.concatenate([time.reshape((-1, 1)), emotion], axis=1) + + def g(x, z, p): + return storeg(x, p) # doesn't use z + + # errors + e = (ypcor * ynoise / pnoise) * v + rng.randn(n) * ynoise * np.sqrt(1 - ypcor**2) + e = e.reshape(-1, 1) + + # response + y = g(x_latent, None, price) + e + + return (x, + z.reshape((-1, 1)), + price.reshape((-1, 1)), + y.reshape((-1, 1)), + g) + + def datafunction(n, s, test=False): + return demand(n=n, seed=s, ypcor=0.5, test=test) + + n = 1000 + epochs = 50 + x, z, t, y, g_true = datafunction(n, 1) + + print("Data shapes:\n\ +Features:{x},\n\ +Instruments:{z},\n\ +Treament:{t},\n\ +Response:{y}".format(**{'x': x.shape, 'z': z.shape, + 't': t.shape, 'y': y.shape})) + + losses = [] + + for (n1, u, n2) in [(2, False, None), (2, True, None), (1, False, 1)]: + treatment_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(9,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17)]) + + hmodel = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(9,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(1)]) + + deepIv = DeepIV(n_components=10, + m=lambda z, x: treatment_model(keras.layers.concatenate([z, x])), + h=lambda t, x: hmodel(keras.layers.concatenate([t, x])), + n_samples=n1, use_upper_bound_loss=u, n_gradient_samples=n2, + first_stage_options={'epochs': epochs}, second_stage_options={'epochs': epochs}) + deepIv.fit(y, t, X=x, Z=z) + + losses.append(monte_carlo_error(lambda x, z, t: deepIv.predict( + t, x), datafunction, has_latent=False, debug=False)) + print("losses: {}".format(losses)) + + @pytest.mark.slow + def test_deepiv_models_paper2(self): + def monte_carlo_error(g_hat, data_fn, ntest=5000, has_latent=False, debug=False): + seed = np.random.randint(1e9) + try: + # test = True ensures we draw test set images + x, z, t, y, g_true = data_fn(ntest, seed, test=True) + except ValueError: + warnings.warn("Too few images, reducing test set size") + ntest = int(ntest * 0.7) + # test = True ensures we draw test set images + x, z, t, y, g_true = data_fn(ntest, seed, test=True) + + # re-draw to get new independent treatment and implied response + t = np.linspace(np.percentile(t, 2.5), np.percentile(t, 97.5), ntest).reshape(-1, 1) + # we need to make sure z _never_ does anything in these g functions (fitted and true) + # above is necesary so that reduced form doesn't win + if has_latent: + x_latent, _, _, _, _ = data_fn(ntest, seed, images=False) + y = g_true(x_latent, z, t) + else: + y = g_true(x, z, t) + y_true = y.flatten() + y_hat = g_hat(x, z, t).flatten() + return ((y_hat - y_true)**2).mean() + + def one_hot(col, **kwargs): + z = col.reshape(-1, 1) + enc = OneHotEncoder(sparse_output=False, **kwargs) + return enc.fit_transform(z) + + def sensf(x): + return 2.0 * ((x - 5)**4 / 600 + np.exp(-((x - 5) / 0.5)**2) + x / 10. - 2) + + def emocoef(emo): + emoc = (emo * np.array([1., 2., 3., 4., 5., 6., 7.])[None, :]).sum(axis=1) + return emoc + + psd = 3.7 + pmu = 17.779 + ysd = 158. # 292. + ymu = -292.1 + + def storeg(x, price): + emoc = emocoef(x[:, 1:]) + time = x[:, 0] + g = sensf(time) * emoc * 10. + (6 * emoc * sensf(time) - 2.0) * (psd * price.flatten() + pmu) + y = (g - ymu) / ysd + return y.reshape(-1, 1) + + def demand(n, seed=1, ynoise=1., pnoise=1., ypcor=0.8, test=False): + rng = np.random.RandomState(seed) + + # covariates: time and emotion + time = rng.rand(n) * 10 + emotion_id = rng.randint(0, 7, size=n) + emotion = one_hot(emotion_id, categories=[np.arange(7)]) + emotion_feature = emotion + + # random instrument + z = rng.randn(n) + + # z -> price + v = rng.randn(n) * pnoise + price = sensf(time) * (z + 3) + 25. + price = price + v + price = (price - pmu) / psd + + # true observable demand function + x = np.concatenate([time.reshape((-1, 1)), emotion_feature], axis=1) + x_latent = np.concatenate([time.reshape((-1, 1)), emotion], axis=1) + + def g(x, z, p): + return storeg(x, p) # doesn't use z + + # errors + e = (ypcor * ynoise / pnoise) * v + rng.randn(n) * ynoise * np.sqrt(1 - ypcor**2) + e = e.reshape(-1, 1) + + # response + y = g(x_latent, None, price) + e + + return (x, + z.reshape((-1, 1)), + price.reshape((-1, 1)), + y.reshape((-1, 1)), + g) + + def datafunction(n, s, test=False): + return demand(n=n, seed=s, ypcor=0.5, test=test) + + n = 1000 + epochs = 20 + + x, z, t, y, g_true = datafunction(n, 1) + + print("Data shapes:\n\ + Features:{x},\n\ + Instruments:{z},\n\ + Treament:{t},\n\ + Response:{y}".format(**{'x': x.shape, 'z': z.shape, + 't': t.shape, 'y': y.shape})) + + losses = [] + + for (n1, u, n2) in [(2, False, None), (2, True, None), (1, False, 1)]: + treatment_model = keras.Sequential([keras.layers.Dense(50, activation='relu', input_shape=(9,)), + keras.layers.Dense(25, activation='relu'), + keras.layers.Dense(25, activation='relu')]) + + hmodel = keras.Sequential([keras.layers.Dense(50, activation='relu', input_shape=(9,)), + keras.layers.Dense(25, activation='relu'), + keras.layers.Dense(25, activation='relu'), + keras.layers.Dense(1)]) + + deepIv = DeepIV(n_components=10, + m=lambda z, x: treatment_model(keras.layers.concatenate([z, x])), + h=lambda t, x: hmodel(keras.layers.concatenate([t, x])), + n_samples=n1, use_upper_bound_loss=u, n_gradient_samples=n2, + first_stage_options={'epochs': epochs}, second_stage_options={'epochs': epochs}) + deepIv.fit(y, t, X=x, Z=z) + + losses.append(monte_carlo_error(lambda x, z, t: deepIv.predict( + t, x), datafunction, has_latent=False, debug=False)) + print("losses: {}".format(losses)) + + @pytest.mark.slow + def test_mog_models(self): + d = 2 + n = 5 + + theta = np.random.uniform(low=0.0, high=2 * np.pi, size=(5000, d)) + x = 10 * np.cos(theta) + np.random.normal(size=(5000, d)) + t = 10 * np.sin(theta) + np.random.normal(size=(5000, d)) + + x_input = keras.layers.Input(shape=(d,)) + l1 = keras.layers.Dense(10, activation='relu') + l2 = keras.layers.Dense(10, activation='relu') + l3 = keras.layers.Dense(10, activation='relu') + + def norm(lr): + return lr # keras.layers.BatchNormalization() + + x_network = l3(norm(l2(norm(l1(x_input))))) + + t_input = keras.layers.Input(shape=(d,)) + + pi, mu, sig = mog_model(n, 10, d)(x_network) + ll = mog_loss_model(n, d)([pi, mu, sig, t_input]) + samp = mog_sample_model(n, d) + + samp2 = keras.layers.Concatenate()([samp([pi, mu, sig]), samp([pi, mu, sig])]) + + # pi,mu,sig = MixtureOfGaussians(n, d)(x_network) + # ll = MixtureOfGaussiansLogLoss(n, d)([pi,mu,sig,t_input]) + model = keras.engine.Model([x_input, t_input], [ll]) + model.add_loss(K.mean(ll)) + model.compile('nadam') + model.fit([x, t], [], epochs=5) + + # For some reason this doesn't work at all when run against the CNTK backend... + # model.compile('nadam', loss=lambda _,l:l) + # model.fit([x,t], [np.zeros((5000,1))], epochs=500) + + model2 = keras.engine.Model([x_input], [pi, mu, sig]) + model3 = keras.engine.Model([x_input], [samp([pi, mu, sig])]) + model4 = keras.engine.Model([x_input], [samp2]) + + print("samp2: {}".format(model4.predict(np.array([[0., 0.]])))) + + for x_i in [-10, -5, 0, 5, 10]: + t = np.array([[np.sqrt(100 - x_i**2), -np.sqrt(100 - x_i**2)]]) + outs = model2.predict([np.array([[x_i, x_i]])]) + print(x_i, outs) + + # generate a valiation set + x = 10 * np.cos(theta) + np.random.normal(size=(5000, d)) + t = 10 * np.sin(theta) + np.random.normal(size=(5000, d)) + pi, mu, sig = model2.predict([x]) + sampled_t = model3.predict([x]) + + print(pi[0], mu[0], sig[0], x[0], t[0]) + import io + with io.open("sampled_{}.csv".format(K.backend()), 'w') as f: + for (x1, x2), (t1, t2) in zip(x, sampled_t): + f.write("{},{},{},{}\n".format(x1, t1, x2, t2)) + + @pytest.mark.slow + def test_mog_models2(self): + def sample(n): + x = np.random.uniform(size=2) + return (n + 1) * x[0] if x[0] ** n > x[1] else sample(n) + + n_comp = 20 + + x = np.random.uniform(high=2, size=2000) + t = np.array([sample(n) for n in x]) + + x_network = keras.Sequential([keras.layers.Dense(10, activation='relu'), + keras.layers.Dense(10, activation='relu'), + keras.layers.Dense(10, activation='relu')]) + + x_input, t_input = [keras.layers.Input(shape=(d,)) for d in [1, 1]] + + pi, mu, sig = mog_model(n_comp, 10, 1)(x_network(x_input)) + ll = mog_loss_model(n_comp, 1)([pi, mu, sig, t_input]) + + model = keras.engine.Model([x_input, t_input], [ll]) + model.add_loss(K.mean(ll)) + model.compile('nadam') + model.fit([x, t], [], epochs=100) + + model2 = keras.engine.Model([x_input], [pi, mu, sig]) + import matplotlib + matplotlib.use('Agg') + import matplotlib.pyplot as plt + for x in [0, 1, 2]: + pi, mu, sig = model2.predict(np.array([[x]])) + mu = mu.reshape(-1) + + def f(t): + return np.sum(pi / (np.sqrt(2 * np.pi) * sig) * np.exp(-np.square((t - mu) / sig) / 2)) + ts = np.linspace(-0.1, x + 1.1, 100) + plt.figure() + plt.plot(ts, [f(t) for t in ts]) + plt.plot(ts, [(t / (x + 1)) ** x for t in ts]) + plt.show() + + @pytest.mark.slow + def test_deepiv_arbitrary_covariance(self): + d = 5 + n = 5000 + # to generate a random symmetric positive semidefinite covariance matrix, we can use A*A^T + A1 = np.random.normal(size=(d, d)) + cov1 = np.matmul(A1, np.transpose(A1)) + # convex combinations of semidefinite covariance matrices are themselves semidefinite + A2 = np.random.normal(size=(d, d)) + cov2 = np.matmul(A2, np.transpose(A2)) + m1 = np.random.normal(size=(d,)) + m2 = np.random.normal(size=(d,)) + x = np.random.uniform(size=(n, 1)) + z = np.random.uniform(size=(n, 1)) + alpha = (x * x + z * z) / 2 # in range [0,1] + t = np.array([np.random.multivariate_normal(m1 + alpha[i] * (m2 - m1), + cov1 + alpha[i] * (cov2 - cov1)) for i in range(n)]) + y = np.expand_dims(np.einsum('nx,nx->n', t, t), -1) + x + results = [] + s = 6 + for (n1, u, n2) in [(2, False, None), (2, True, None), (1, False, 1)]: + treatment_model = keras.Sequential([keras.layers.Dense(90, activation='relu', input_shape=(2,)), + keras.layers.Dropout(0.2), + keras.layers.Dense(60, activation='relu'), + keras.layers.Dropout(0.2), + keras.layers.Dense(30, activation='relu')]) + + hmodel = keras.Sequential([keras.layers.Dense(90, activation='relu', input_shape=(d + 1,)), + keras.layers.Dropout(0.2), + keras.layers.Dense(60, activation='relu'), + keras.layers.Dropout(0.2), + keras.layers.Dense(30, activation='relu'), + keras.layers.Dropout(0.2), + keras.layers.Dense(1)]) + + deepIv = DeepIV(n_components=s, + m=lambda z, x: treatment_model(keras.layers.concatenate([z, x])), + h=lambda t, x: hmodel(keras.layers.concatenate([t, x])), + n_samples=n1, use_upper_bound_loss=u, n_gradient_samples=n2, + first_stage_options={'epochs': 20}, second_stage_options={'epochs': 20}) + deepIv.fit(y[:n // 2], t[:n // 2], X=x[:n // 2], Z=z[:n // 2]) + + results.append({'s': s, 'n1': n1, 'u': u, 'n2': n2, + 'loss': np.mean(np.square(y[n // 2:] - deepIv.predict(t[n // 2:], x[n // 2:]))), + 'marg': deepIv.marginal_effect(np.array([[0.5] * d]), np.array([[1.0]]))}) + print(results) diff --git a/econml/tests/test_integration.py b/econml/tests/test_integration.py index ebd689c33..8b82f5563 100644 --- a/econml/tests/test_integration.py +++ b/econml/tests/test_integration.py @@ -5,7 +5,13 @@ import numpy as np import pandas as pd import unittest +import pytest +try: + import keras + keras_installed = True +except ImportError: + keras_installed = False from econml.dr import LinearDRLearner, SparseLinearDRLearner, ForestDRLearner from econml.dml import LinearDML, SparseLinearDML, CausalForestDML @@ -17,6 +23,7 @@ from sklearn.linear_model import MultiTaskLasso, LassoCV from sklearn.preprocessing import PolynomialFeatures, FunctionTransformer from econml.iv.dr import LinearIntentToTreatDRIV +from econml.iv.nnet import DeepIV class TestPandasIntegration(unittest.TestCase): @@ -203,6 +210,34 @@ def test_orthoiv(self): self._check_input_names(est.summary()) # Check input names propagate self._check_popsum_names(est.effect_inference(X).population_summary()) + @pytest.mark.skipif(not keras_installed, reason="Keras not installed") + def test_deepiv(self): + X = TestPandasIntegration.df[TestPandasIntegration.features] + Y = TestPandasIntegration.df[TestPandasIntegration.outcome] + T = TestPandasIntegration.df[TestPandasIntegration.cont_treat] + Z = TestPandasIntegration.df[TestPandasIntegration.instrument] + # Test DeepIV + treatment_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(3,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17)]) + response_model = keras.Sequential([keras.layers.Dense(128, activation='relu', input_shape=(3,)), + keras.layers.Dropout(0.17), + keras.layers.Dense(64, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(32, activation='relu'), + keras.layers.Dropout(0.17), + keras.layers.Dense(1)]) + est = DeepIV(n_components=10, # Number of gaussians in the mixture density networks) + m=lambda z, x: treatment_model(keras.layers.concatenate([z, x])), # Treatment model + h=lambda t, x: response_model(keras.layers.concatenate([t, x])), # Response model + n_samples=1 # Number of samples used to estimate the response + ) + est.fit(Y, T, X=X, Z=Z) + _treatment_effects = est.effect(X) + def test_cat_treatments(self): X = TestPandasIntegration.df[TestPandasIntegration.features] Y = TestPandasIntegration.df[TestPandasIntegration.outcome] diff --git a/notebooks/Deep IV Examples.ipynb b/notebooks/Deep IV Examples.ipynb new file mode 100644 index 000000000..12fb856d4 --- /dev/null +++ b/notebooks/Deep IV Examples.ipynb @@ -0,0 +1,607 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deep IV: Use Case and Examples\n", + "\n", + "Deep IV uses deep neural networks in a two-stage instrumental variable (IV) estimation of causal effects, as described in [this ICML publication](http://proceedings.mlr.press/v70/hartford17a/hartford17a.pdf) or in the `econml` [specification](https://econml.azurewebsites.net/spec/estimation/deepiv.html). In the EconML SDK, we have implemented Deep IV estimation on top of the Keras framework for building and training neural networks. In this notebook, we'll demonstrate how to use the SDK to apply Deep IV to synthetic data.\n", + "\n", + "### Data\n", + "\n", + "Deep IV works in settings where we have several different types of observations:\n", + "* Covariates, which we will denote with `X`\n", + "* Instruments, which we will denote with `Z`\n", + "* Treatments, which we will denote with `T`\n", + "* Responses, which we will denote with `Y`\n", + "\n", + "The main requirement is that `Z` is a set of valid instruments; in particular `Z` should affect the responses `Y` only through the treatments `T`. We assume that `Y` is an arbitrary function of `T` and `X`, plus an additive error term, and that `T` is an arbitrary function of `Z` and `X`. Deep IV then allows us to estimate `Y` given `T` and `X`.\n", + "\n", + "### Estimation\n", + "\n", + "To do this, the Deep IV estimator uses a two-stage approach that involves solving two subproblems:\n", + "1. It estimates the *distribution* of the treatment `T` given `Z` and `X`, using a mixture density network.\n", + "2. It estimates the dependence of the response `Y` on `T` and `X`.\n", + "\n", + "Both of these estimates are performed using neural networks. See the paper for a more complete description of the setup and estimation approach.\n", + "\n", + "### Using the SDK\n", + "\n", + "In the `econml` package, our Deep IV estimator is built on top of the Keras framework; we support either the Tensorflow or the Theano backends. There are three steps to using the `DeepIV`:\n", + "\n", + "1. Construct an instance. \n", + " * The `m` and `h` arguments to the initializer specify deep neural network models for estimating `T` and `Y` as described above. They are each *functions* that take two Keras inputs and return a Keras model (the inputs are `z` and `x` in the case of `m` and the output's shape should match `t`'s; the inputs are `t` and `x` in the case of `h` and the output's shape should match `y`'s). Note that the `h` function will be called multiple times, but should reuse the same weights - see below for a concrete example of how to achieve this using the Keras API.\n", + " * The `n_samples`, `use_upper_bound_loss`, and `n_gradient_samples` arguments together determine how the loss for the response model will be computed.\n", + " * If `use_upper_bound_loss` is `False` and `n_gradient_samples` is zero, then `n_samples` samples will be averaged to approximate the response - this will provide an unbiased estimate of the correct loss only in the limit as the number of samples goes to infinity.\n", + " * If `use_upper_bound_loss` is `False` and `n_gradient_samples` is nonzero, then we will average `n_samples` samples to approximate the response a first time and average `n_gradient_samples` samples to approximate it a second time - combining these allows us to provide an unbiased estimate of the true loss.\n", + " * If `use_upper_bound_loss` is `True`, then `n_gradient_samples` must be `0`; `n_samples` samples will be used to get an unbiased estimate of an upper bound of the true loss - this is equivalent to adding a regularization term penalizing the variance of the response model (see the `econml` specification linked above for a derivation of this fact).\n", + "2. Call `fit` with training samples of `Y`, `T`, `X`, and `Z`; this will train both sub-models.\n", + "3. Call `effect` or `predict` depending on what output you want. `effect` calculates the difference in outcomes based on the features and two different treatments, while `predict` predicts the outcome based on a single treatment.\n", + "\n", + "The remainder of this notebook will walk through a concete example." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Synthetic data\n", + "\n", + "To demonstrate the Deep IV approach, we'll construct a synthetic dataset obeying the requirements set out above. In this case, we'll take `X`, `Z`, `T` to come from the following distribution: " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = 5000\n", + "\n", + "# Initialize exogenous variables; normal errors, uniformly distributed covariates and instruments\n", + "e = np.random.normal(size=(n,))\n", + "x = np.random.uniform(low=0.0, high=10.0, size=(n,))\n", + "z = np.random.uniform(low=0.0, high=10.0, size=(n,))\n", + "\n", + "# Initialize treatment variable\n", + "t = np.sqrt((x+2) * z) + e\n", + "\n", + "# Show the marginal distribution of t\n", + "plt.hist(t)\n", + "plt.xlabel(\"t\")\n", + "plt.show()\n", + "\n", + "plt.scatter(z[x < 1], t[x < 1], label='low X')\n", + "plt.scatter(z[(x > 4.5) * (x < 5.5)], t[(x > 4.5) * (x < 5.5)], label='moderate X')\n", + "plt.scatter(z[x > 9], t[x > 9], label='high X')\n", + "plt.legend()\n", + "plt.xlabel(\"z\")\n", + "plt.ylabel(\"t\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The instrument is positively correlated with the treatment and treatments tend to be bigger at high values of x. The instrument has higher power at higher values of x " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Outcome equation\n", + "y = t*t / 10 - x*t / 10 + e\n", + "\n", + "# The endogeneity problem is clear, the latent error enters both treatment and outcome equally\n", + "plt.scatter(t,y, label ='raw data')\n", + "tticks = np.arange(-2,12)\n", + "yticks2 = tticks*tticks/10 - 0.2 * tticks\n", + "yticks5 = tticks*tticks/10 - 0.5 * tticks\n", + "yticks8 = tticks*tticks/10 - 0.8 * tticks\n", + "plt.plot(tticks,yticks2, 'r--', label = 'truth, x=2')\n", + "plt.plot(tticks,yticks5, 'g--', label = 'truth, x=5')\n", + "plt.plot(tticks,yticks8, 'y--', label = 'truth, x=8')\n", + "plt.xlabel(\"t\")\n", + "plt.ylabel(\"y\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Y` is a non-linear function of `T` and `X` with no direct dependence on `Z` plus additive noise (as required). We want to estimate the effect of particular `T` and `X` values on `Y`.\n", + "\n", + "The plot makes it clear that looking at the raw data is highly misleading as to the treatment effect. Moreover the treatment effects are both non-linear and heterogeneous in x, so this is a hard problem!\n", + "\n", + "## Defining the neural network models\n", + "\n", + "Now we'll define simple treatment and response models using the Keras `Sequential` model built up of a series of layers. Each model will have an `input_shape` of 2 (to match the sums of the dimensions of `X` plus `Z` in the treatment case and `T` plus `X` in the response case)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " does not define `arg_constraints`. Please set `arg_constraints = {}` or initialize the distribution with `validate_args=False` to turn off validation.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average loss for epoch 1: 1.8513488521575927\n", + "Average loss for epoch 2: 1.4667842819213868\n", + "Average loss for epoch 3: 1.4563055910110474\n", + "Average loss for epoch 4: 1.4522802669525146\n", + "Average loss for epoch 5: 1.4494349975585938\n", + "Average loss for epoch 6: 1.4484461849212646\n", + "Average loss for epoch 7: 1.4462239681243896\n", + "Average loss for epoch 8: 1.4450883716583252\n", + "Average loss for epoch 9: 1.4437531562805175\n", + "Average loss for epoch 10: 1.44318929271698\n", + "Average loss for epoch 11: 1.4425278652191162\n", + "Average loss for epoch 12: 1.4419240463256835\n", + "Average loss for epoch 13: 1.4417274311065673\n", + "Average loss for epoch 14: 1.441357619857788\n", + "Average loss for epoch 15: 1.4400519771575928\n", + "Average loss for epoch 16: 1.4415979846954345\n", + "Average loss for epoch 17: 1.4409125637054443\n", + "Average loss for epoch 18: 1.4407597232818603\n", + "Average loss for epoch 19: 1.4399231178283691\n", + "Average loss for epoch 20: 1.4397638774871826\n", + "Average loss for epoch 21: 1.4398642248153686\n", + "Average loss for epoch 22: 1.4399810117721559\n", + "Average loss for epoch 23: 1.4405021104812623\n", + "Average loss for epoch 24: 1.438953978919983\n", + "Average loss for epoch 25: 1.4393082738876344\n", + "Average loss for epoch 26: 1.4391356311798096\n", + "Average loss for epoch 27: 1.4405723909378052\n", + "Average loss for epoch 28: 1.43939108543396\n", + "Average loss for epoch 29: 1.4397382474899292\n", + "Average loss for epoch 30: 1.4408628210067749\n", + "Average loss for epoch 31: 1.438128600883484\n", + "Average loss for epoch 32: 1.4393175603866577\n", + "Average loss for epoch 33: 1.4373584503173829\n", + "Average loss for epoch 34: 1.4377948631286621\n", + "Average loss for epoch 35: 1.4370364944458007\n", + "Average loss for epoch 36: 1.4378328992843628\n", + "Average loss for epoch 37: 1.437584839630127\n", + "Average loss for epoch 38: 1.437007735824585\n", + "Average loss for epoch 39: 1.4356933868408204\n", + "Average loss for epoch 40: 1.4363660743713378\n", + "Average loss for epoch 41: 1.4346580759048462\n", + "Average loss for epoch 42: 1.435152168083191\n", + "Average loss for epoch 43: 1.4361954904556273\n", + "Average loss for epoch 44: 1.4348722578048707\n", + "Average loss for epoch 45: 1.4352527032852174\n", + "Average loss for epoch 46: 1.4344428863525391\n", + "Average loss for epoch 47: 1.435059776687622\n", + "Average loss for epoch 48: 1.4355759399414063\n", + "Average loss for epoch 49: 1.4343225788116456\n", + "Average loss for epoch 50: 1.434590615081787\n", + "Average loss for epoch 51: 1.434637355041504\n", + "Average loss for epoch 52: 1.4346222400665283\n", + "Average loss for epoch 53: 1.4341433296203614\n", + "Average loss for epoch 54: 1.433864384841919\n", + "Average loss for epoch 55: 1.434030502319336\n", + "Average loss for epoch 56: 1.4338231998443602\n", + "Average loss for epoch 57: 1.43345096988678\n", + "Average loss for epoch 58: 1.4338462753295897\n", + "Average loss for epoch 59: 1.4342108127593993\n", + "Average loss for epoch 60: 1.4329557416915895\n", + "Average loss for epoch 61: 1.4335955787658692\n", + "Average loss for epoch 62: 1.4332177864074707\n", + "Average loss for epoch 63: 1.433483260154724\n", + "Average loss for epoch 64: 1.4335605625152588\n", + "Average loss for epoch 65: 1.4330878406524659\n", + "Average loss for epoch 66: 1.4327959007263185\n", + "Average loss for epoch 67: 1.4325269004821777\n", + "Average loss for epoch 68: 1.4322606687545776\n", + "Average loss for epoch 69: 1.432740470123291\n", + "Average loss for epoch 70: 1.433312495803833\n", + "Average loss for epoch 71: 1.4328523822784425\n", + "Average loss for epoch 72: 1.4321181957244873\n", + "Average loss for epoch 73: 1.4324961688995361\n", + "Average loss for epoch 74: 1.4318281894683837\n", + "Average loss for epoch 75: 1.4318357700347901\n", + "Average loss for epoch 76: 1.4315551403045654\n", + "Average loss for epoch 77: 1.4324572376251221\n", + "Average loss for epoch 78: 1.4324217826843262\n", + "Average loss for epoch 79: 1.4314765495300292\n", + "Average loss for epoch 80: 1.4309081865310669\n", + "Average loss for epoch 81: 1.4313651678085326\n", + "Average loss for epoch 82: 1.431236773300171\n", + "Average loss for epoch 83: 1.4308138080596924\n", + "Average loss for epoch 84: 1.4300491624832152\n", + "Average loss for epoch 85: 1.43008856716156\n", + "Average loss for epoch 86: 1.4298199029922485\n", + "Average loss for epoch 87: 1.42981048412323\n", + "Average loss for epoch 88: 1.4297285060882567\n", + "Average loss for epoch 89: 1.4290369943618775\n", + "Average loss for epoch 90: 1.4287299558639526\n", + "Average loss for epoch 91: 1.4293051424026488\n", + "Average loss for epoch 92: 1.4304704809188842\n", + "Average loss for epoch 93: 1.4298982185363769\n", + "Average loss for epoch 94: 1.4291842853546142\n", + "Average loss for epoch 95: 1.4289434858322143\n", + "Average loss for epoch 96: 1.429131128692627\n", + "Average loss for epoch 97: 1.4291901302337646\n", + "Average loss for epoch 98: 1.428347722053528\n", + "Average loss for epoch 99: 1.4283289009094238\n", + "Average loss for epoch 100: 1.42743939037323\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch import nn\n", + "from econml.iv.nnet import MixtureOfGaussiansModule\n", + "\n", + "treatment_model = MixtureOfGaussiansModule(n_components=50, d_t=1, d_z=1, d_x=1)\n", + "\n", + "def fit_trt():\n", + " Y, T, X, Z = [torch.from_numpy(a).float().reshape(-1,1) for a in (y, t, x, z)]\n", + "\n", + " opt = torch.optim.Adam(treatment_model.parameters())\n", + " for epoch in range(100):\n", + " total_loss = 0\n", + " for i in range(0, len(T), 32):\n", + " opt.zero_grad()\n", + " loss = -treatment_model(Z[i:i+32], X[i:i+32]).log_prob(T[i:i+32]).sum()\n", + " total_loss += loss.item()\n", + " loss.backward()\n", + " opt.step()\n", + " print(f\"Average loss for epoch {epoch+1}: {total_loss / len(T)}\")\n", + "\n", + " treatment_model.eval()\n", + "\n", + "fit_trt()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "response_model = nn.Sequential(nn.Linear(2, 512), nn.ReLU(),\n", + " nn.Linear(512, 512), nn.ReLU(),\n", + " nn.Linear(512, 1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we'll instantiate the `DeepIV` class using these models. Defining the response model *outside* of the lambda passed into constructor is important, because (depending on the settings for the loss) it can be used multiple times in the second stage and we want the same weights to be used every time." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average loss for epoch 1: 3.4273843544006346\n", + "Average loss for epoch 2: 3.2191349571228027\n", + "Average loss for epoch 3: 3.1888333602905274\n", + "Average loss for epoch 4: 3.2357241477966308\n", + "Average loss for epoch 5: 3.1786253692626953\n", + "Average loss for epoch 6: 3.200181683731079\n", + "Average loss for epoch 7: 3.250414537811279\n", + "Average loss for epoch 8: 3.2738863136291503\n", + "Average loss for epoch 9: 3.2214389793395997\n", + "Average loss for epoch 10: 3.232039263153076\n", + "Average loss for epoch 11: 3.183742478942871\n", + "Average loss for epoch 12: 3.159575353240967\n", + "Average loss for epoch 13: 3.262701205444336\n", + "Average loss for epoch 14: 3.2386261138916015\n", + "Average loss for epoch 15: 3.1761450202941894\n", + "Average loss for epoch 16: 3.2254007938385008\n", + "Average loss for epoch 17: 3.2605581809997557\n", + "Average loss for epoch 18: 3.1916280044555663\n", + "Average loss for epoch 19: 3.2291911239624023\n", + "Average loss for epoch 20: 3.1627709341049193\n", + "Average loss for epoch 21: 3.237530876159668\n", + "Average loss for epoch 22: 3.2121072814941405\n", + "Average loss for epoch 23: 3.2372874450683593\n", + "Average loss for epoch 24: 3.1307517517089845\n", + "Average loss for epoch 25: 3.1625765419006346\n", + "Average loss for epoch 26: 3.200332936668396\n", + "Average loss for epoch 27: 3.2190249729156495\n", + "Average loss for epoch 28: 3.151433866882324\n", + "Average loss for epoch 29: 3.2503201919555664\n", + "Average loss for epoch 30: 3.2913422927856444\n", + "Average loss for epoch 31: 3.205851180267334\n", + "Average loss for epoch 32: 3.230084772872925\n", + "Average loss for epoch 33: 3.2082397605895996\n", + "Average loss for epoch 34: 3.2758080711364745\n", + "Average loss for epoch 35: 3.2061112247467043\n", + "Average loss for epoch 36: 3.2414241119384766\n", + "Average loss for epoch 37: 3.223182733535767\n", + "Average loss for epoch 38: 3.238316358566284\n", + "Average loss for epoch 39: 3.2076307079315187\n", + "Average loss for epoch 40: 3.188707131958008\n", + "Average loss for epoch 41: 3.121509253692627\n", + "Average loss for epoch 42: 3.2724685150146486\n", + "Average loss for epoch 43: 3.227390997695923\n", + "Average loss for epoch 44: 3.234863991546631\n", + "Average loss for epoch 45: 3.248421272659302\n", + "Average loss for epoch 46: 3.1987249378204345\n", + "Average loss for epoch 47: 3.3367460176467896\n", + "Average loss for epoch 48: 3.2402408729553223\n", + "Average loss for epoch 49: 3.2553707489013672\n", + "Average loss for epoch 50: 3.157371636962891\n", + "Average loss for epoch 51: 3.2308546855926514\n", + "Average loss for epoch 52: 3.2013729774475097\n", + "Average loss for epoch 53: 3.2117363079071044\n", + "Average loss for epoch 54: 3.1808130798339844\n", + "Average loss for epoch 55: 3.2266653762817383\n", + "Average loss for epoch 56: 3.271760501098633\n", + "Average loss for epoch 57: 3.2611998106002806\n", + "Average loss for epoch 58: 3.2767563999176024\n", + "Average loss for epoch 59: 3.27824776763916\n", + "Average loss for epoch 60: 3.275167158508301\n", + "Average loss for epoch 61: 3.2550024723052977\n", + "Average loss for epoch 62: 3.2587358879089354\n", + "Average loss for epoch 63: 3.1933490432739258\n", + "Average loss for epoch 64: 3.193686423110962\n", + "Average loss for epoch 65: 3.1860505088806153\n", + "Average loss for epoch 66: 3.288464321899414\n", + "Average loss for epoch 67: 3.2864183113098147\n", + "Average loss for epoch 68: 3.301669193267822\n", + "Average loss for epoch 69: 3.26502501411438\n", + "Average loss for epoch 70: 3.2501579372406004\n", + "Average loss for epoch 71: 3.243740782928467\n", + "Average loss for epoch 72: 3.226807540893555\n", + "Average loss for epoch 73: 3.263482594299316\n", + "Average loss for epoch 74: 3.330228311920166\n", + "Average loss for epoch 75: 3.359158192443848\n", + "Average loss for epoch 76: 3.241581906890869\n", + "Average loss for epoch 77: 3.269939069366455\n", + "Average loss for epoch 78: 3.2759755264282227\n", + "Average loss for epoch 79: 3.3023689981460573\n", + "Average loss for epoch 80: 3.2909591835021974\n", + "Average loss for epoch 81: 3.2463582275390626\n", + "Average loss for epoch 82: 3.2453032157897947\n", + "Average loss for epoch 83: 3.2112409492492677\n", + "Average loss for epoch 84: 3.156226461029053\n", + "Average loss for epoch 85: 3.2132443264007566\n", + "Average loss for epoch 86: 3.22359446144104\n", + "Average loss for epoch 87: 3.273238780593872\n", + "Average loss for epoch 88: 3.2531851165771486\n", + "Average loss for epoch 89: 3.2049300621032715\n", + "Average loss for epoch 90: 3.2259070960998537\n", + "Average loss for epoch 91: 3.301566777038574\n", + "Average loss for epoch 92: 3.2495092388153077\n", + "Average loss for epoch 93: 3.287779102706909\n", + "Average loss for epoch 94: 3.234177515411377\n", + "Average loss for epoch 95: 3.275179343414307\n", + "Average loss for epoch 96: 3.2486909790039062\n", + "Average loss for epoch 97: 3.269638641357422\n", + "Average loss for epoch 98: 3.269698161315918\n", + "Average loss for epoch 99: 3.2782866355895997\n", + "Average loss for epoch 100: 3.241651856994629\n" + ] + } + ], + "source": [ + "def fit_resp():\n", + " Y, T, X, Z = [torch.from_numpy(a).float().reshape(-1,1) for a in (y, t, x, z)]\n", + "\n", + " opt = torch.optim.Adam(response_model.parameters())\n", + " for epoch in range(100):\n", + " total_loss = 0\n", + " for i in range(0, len(Y), 32):\n", + " opt.zero_grad()\n", + " t_s = treatment_model(Z[i:i+32], X[i:i+32]).sample((1,))\n", + " t_g = treatment_model(Z[i:i+32], X[i:i+32]).sample((1,))\n", + " y_g = response_model(torch.cat((t_g, X[i:i+32].expand(t_g.size())), dim=-1)).mean(dim=0)\n", + " with torch.no_grad():\n", + " diff = Y[i:i+32] - response_model(torch.cat((t_s, X[i:i+32].expand(t_g.size())), dim=-1)).mean(dim=0)\n", + " diff_2 = diff + 2 * y_g\n", + " loss = (diff * (diff_2 - 2 * y_g)).sum()\n", + " total_loss += loss.item()\n", + " loss.backward()\n", + " opt.step()\n", + " print(f\"Average loss for epoch {epoch+1}: {total_loss / len(Y)}\")\n", + "\n", + " response_model.eval()\n", + "\n", + "fit_resp()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting and predicting using the model\n", + "Now we can fit our model to the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train on 4500 samples, validate on 500 samples\n", + "Epoch 1/30\n", + "4500/4500 [==============================] - 2s 380us/step - loss: 1.6199 - val_loss: 0.8568\n", + "Epoch 2/30\n", + "4500/4500 [==============================] - 1s 116us/step - loss: 1.1357 - val_loss: 0.6315\n", + "Epoch 3/30\n", + "4500/4500 [==============================] - 1s 117us/step - loss: 0.9836 - val_loss: 0.7512\n", + "Epoch 4/30\n", + "4500/4500 [==============================] - 1s 118us/step - loss: 0.8963 - val_loss: 0.7189\n", + "Train on 4500 samples, validate on 500 samples\n", + "Epoch 1/30\n", + "4500/4500 [==============================] - 3s 774us/step - loss: 4.8558 - val_loss: 3.0255\n", + "Epoch 2/30\n", + "4500/4500 [==============================] - 1s 183us/step - loss: 5.1271 - val_loss: 2.9335\n", + "Epoch 3/30\n", + "4500/4500 [==============================] - 1s 187us/step - loss: 5.0416 - val_loss: 3.1960\n", + "Epoch 4/30\n", + "4500/4500 [==============================] - 1s 198us/step - loss: 5.3328 - val_loss: 3.0213\n" + ] + } + ], + "source": [ + "deepIvEst.fit(Y=y,T=t,X=x,Z=z)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now we can create a new set of data and see whether our predicted effect matches the true effect `T*T-X*X`:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n_test = 500\n", + "for i, x in enumerate([2, 5, 8]):\n", + " t = np.linspace(0,10,num = 100, dtype=np.float32).reshape(-1,1)\n", + " y_true = t*t / 10 - x*t/10\n", + "\n", + " y_pred = response_model(torch.cat((torch.tensor(t), torch.tensor(np.full_like(t, x))), dim=-1)).detach().numpy()\n", + " plt.plot(t, y_true, label='true y, x={0}'.format(x),color='C'+str(i))\n", + " plt.plot(t, y_pred, label='pred y, x={0}'.format(x),color='C'+str(i),ls='--')\n", + "plt.xlabel('t')\n", + "plt.ylabel('y')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that despite the fact that the response surface varies with x, our model was able to fit the data reasonably well. Where is does worst is where the instrument has the least power, which is in the low x case. There it fits a straight line rather than a quadratic, which suggests that the regularization at least is perfoming well. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pyproject.toml b/pyproject.toml index e9c7f5fdb..9197d61df 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,6 +43,9 @@ automl = [ # azureml-sdk[explain,automl] == 1.0.83 "azure-cli" ] +nn = [ + "torch >= 2" +] plt = [ "graphviz", "matplotlib" @@ -58,6 +61,7 @@ all = [ # Disabled due to incompatibility with scikit-learn # azureml-sdk[explain,automl] == 1.0.83 "azure-cli", + "torch >= 2", "graphviz", "matplotlib", "dowhy < 0.13",