diff --git a/.gitignore b/.gitignore
index 13598e90..046bb388 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,10 @@
 # C extensions
 *.so
 
+# Data and experiment folders
+docs/examples/robust_paper/datasets/
+docs/examples/robust_paper/experiments/
+
 # Packages
 *.egg
 *.egg-info
diff --git a/chirho/robust/handlers/estimators.py b/chirho/robust/handlers/estimators.py
index eb6e8d6e..8eaed460 100644
--- a/chirho/robust/handlers/estimators.py
+++ b/chirho/robust/handlers/estimators.py
@@ -1,8 +1,13 @@
+import copy
+import warnings
 from typing import Any, Callable, TypeVar
 
 import torch
+import torchopt
 from typing_extensions import ParamSpec
 
+from chirho.robust.handlers.predictive import PredictiveFunctional
+from chirho.robust.internals.utils import make_functional_call
 from chirho.robust.ops import Functional, Point, influence_fn
 
 P = ParamSpec("P")
@@ -10,9 +15,220 @@
 T = TypeVar("T")
 
 
+def tmle_scipy_optimize_wrapper(
+    packed_influence, log_jitter: float = 1e-6
+) -> torch.Tensor:
+    import numpy as np
+    import scipy
+    from scipy.optimize import LinearConstraint
+
+    # Turn things into numpy. This makes us sad... :(
+    D = packed_influence.detach().numpy()
+
+    N, L = D.shape[0], D.shape[1]
+
+    def loss(epsilon):
+        correction = 1 + D.dot(epsilon)
+
+        return -np.sum(np.log(np.maximum(correction, log_jitter)))
+
+    positive_density_constraint = LinearConstraint(
+        D, -1 * np.ones(N), np.inf * np.ones(N)
+    )
+
+    epsilon_solve = scipy.optimize.minimize(
+        loss, np.zeros(L, dtype=np.float64), constraints=positive_density_constraint
+    )
+
+    if not epsilon_solve.success:
+        warnings.warn("TMLE optimization did not converge.", RuntimeWarning)
+
+    # Convert epsilon back to torch. This makes us happy... :)
+    packed_epsilon = torch.tensor(epsilon_solve.x, dtype=packed_influence.dtype)
+
+    return packed_epsilon
+
+
+# TODO: revert influence_estimator to influence_fn and use handlers for influence_fn
+def tmle(
+    functional: Functional[P, S],
+    test_point: Point,
+    learning_rate: float = 1e-5,
+    n_grad_steps: int = 100,
+    n_tmle_steps: int = 1,
+    num_nmc_samples: int = 1000,
+    num_grad_samples: int = 1000,
+    log_jitter: float = 1e-6,
+    verbose: bool = False,
+    influence_estimator: Callable[
+        [Functional[P, S], Point[T]], Functional[P, S]
+    ] = influence_fn,
+    **influence_kwargs,
+) -> Functional[P, S]:
+    from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood
+
+    def _solve_epsilon(prev_model: torch.nn.Module, *args, **kwargs) -> torch.Tensor:
+        # find epsilon that minimizes the corrected density on test data
+
+        influence_at_test = influence_estimator(
+            functional, test_point, **influence_kwargs
+        )(prev_model)(*args, **kwargs)
+
+        flat_influence_at_test, _ = torch.utils._pytree.tree_flatten(influence_at_test)
+
+        N = flat_influence_at_test[0].shape[0]
+
+        packed_influence_at_test = torch.concatenate(
+            [i.reshape(N, -1) for i in flat_influence_at_test]
+        )
+
+        packed_epsilon = tmle_scipy_optimize_wrapper(packed_influence_at_test)
+
+        return packed_epsilon
+
+    def _solve_model_projection(
+        packed_epsilon: torch.Tensor,
+        prev_model: torch.nn.Module,
+        *args,
+        **kwargs,
+    ) -> torch.nn.Module:
+        prev_params, functional_model = make_functional_call(
+            PredictiveFunctional(prev_model, num_samples=num_grad_samples)
+        )
+        prev_params = {k: v.detach() for k, v in prev_params.items()}
+
+        # Sample data from the model. Note that we only sample once during projection.
+        with torch.no_grad():
+            data: Point[T] = functional_model(prev_params, *args, **kwargs)
+            data = {k: v.detach() for k, v in data.items() if k in test_point}
+
+        data = {
+            k: v
+            for k, v in functional_model(prev_params, *args, **kwargs).items()
+            if k in test_point
+        }
+
+        batched_log_prob: torch.nn.Module = BatchedNMCLogMarginalLikelihood(
+            prev_model, num_samples=num_nmc_samples
+        )
+
+        _, log_p_phi = make_functional_call(batched_log_prob)
+
+        influence_at_data = influence_estimator(functional, data, **influence_kwargs)(
+            prev_model
+        )(*args, **kwargs)
+        flat_influence_at_data, _ = torch.utils._pytree.tree_flatten(influence_at_data)
+        N_x = flat_influence_at_data[0].shape[0]
+
+        packed_influence_at_data = torch.concatenate(
+            [i.reshape(N_x, -1) for i in flat_influence_at_data]
+        ).detach()
+
+        log_likelihood_correction = torch.log(
+            torch.maximum(
+                1 + packed_influence_at_data.mv(packed_epsilon),
+                torch.tensor(log_jitter),
+            )
+        ).detach()
+        if verbose:
+            influence_at_test = influence_estimator(
+                functional, test_point, **influence_kwargs
+            )(prev_model)(*args, **kwargs)
+            flat_influence_at_test, _ = torch.utils._pytree.tree_flatten(
+                influence_at_test
+            )
+            N = flat_influence_at_test[0].shape[0]
+
+            packed_influence_at_test = torch.concatenate(
+                [i.reshape(N, -1) for i in flat_influence_at_test]
+            ).detach()
+
+            log_likelihood_correction_at_test = torch.log(
+                torch.maximum(
+                    1 + packed_influence_at_test.mv(packed_epsilon),
+                    torch.tensor(log_jitter),
+                )
+            )
+
+            print("previous log prob at test", log_p_phi(prev_params, test_point).sum())
+            print(
+                "new log prob at test",
+                (
+                    log_p_phi(prev_params, test_point)
+                    + log_likelihood_correction_at_test
+                ).sum(),
+            )
+
+        log_p_epsilon_at_data = (
+            log_likelihood_correction + log_p_phi(prev_params, data)
+        ).detach()
+
+        def loss(new_params):
+            log_p_phi_at_data = log_p_phi(new_params, data)
+            return torch.sum((log_p_phi_at_data - log_p_epsilon_at_data) ** 2)
+
+        grad_fn = torch.func.grad(loss)
+
+        new_params = {
+            k: v.clone().detach().requires_grad_(True) for k, v in prev_params.items()
+        }
+
+        optimizer = torchopt.adam(lr=learning_rate)
+
+        optimizer_state = optimizer.init(new_params)
+
+        for i in range(n_grad_steps):
+            grad = grad_fn(new_params)
+            if verbose and i % 100 == 0:
+                print(f"inner_iteration_{i}_loss", loss(new_params))
+                for parameter_name, parameter in prev_model.named_parameters():
+                    parameter.data = new_params[f"model.{parameter_name}"]
+
+                estimate = functional(prev_model)(*args, **kwargs)
+                assert isinstance(estimate, torch.Tensor)
+                print(
+                    f"inner_iteration_{i}_estimate",
+                    estimate.detach().item(),
+                )
+            updates, optimizer_state = optimizer.update(
+                grad, optimizer_state, inplace=False
+            )
+            new_params = torchopt.apply_updates(new_params, updates)
+
+        for parameter_name, parameter in prev_model.named_parameters():
+            parameter.data = new_params[f"model.{parameter_name}"]
+
+        return prev_model
+
+    def _corrected_functional(*models: Callable[P, Any]) -> Callable[P, S]:
+        assert len(models) == 1
+        model = models[0]
+
+        assert isinstance(model, torch.nn.Module)
+
+        def _estimator(*args, **kwargs) -> S:
+            tmle_model = copy.deepcopy(model)
+
+            for _ in range(n_tmle_steps):
+                packed_epsilon = _solve_epsilon(tmle_model, *args, **kwargs)
+
+                tmle_model = _solve_model_projection(
+                    packed_epsilon, tmle_model, *args, **kwargs
+                )
+            return functional(tmle_model)(*args, **kwargs)
+
+        return _estimator
+
+    return _corrected_functional
+
+
+# TODO: revert influence_estimator to influence_fn and use handlers for influence_fn
 def one_step_corrected_estimator(
     functional: Functional[P, S],
     *test_points: Point[T],
+    influence_estimator: Callable[
+        [Functional[P, S], Point[T]], Functional[P, S]
+    ] = influence_fn,
     **influence_kwargs,
 ) -> Functional[P, S]:
     """
@@ -30,7 +246,7 @@ def one_step_corrected_estimator(
     """
     influence_kwargs_one_step = influence_kwargs.copy()
     influence_kwargs_one_step["pointwise_influence"] = False
-    eif_fn = influence_fn(functional, *test_points, **influence_kwargs_one_step)
+    eif_fn = influence_estimator(functional, *test_points, **influence_kwargs_one_step)
 
     def _corrected_functional(*model: Callable[P, Any]) -> Callable[P, S]:
         plug_in_estimator = functional(*model)
diff --git a/docs/examples/robust_paper/analytic_eif.py b/docs/examples/robust_paper/analytic_eif.py
new file mode 100644
index 00000000..bf16ba7a
--- /dev/null
+++ b/docs/examples/robust_paper/analytic_eif.py
@@ -0,0 +1,46 @@
+import torch
+from typing import Tuple
+from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood
+
+
+def analytic_eif_expected_density(test_data, plug_in, model, *args, **kwargs):
+    log_marginal_prob_at_points = BatchedNMCLogMarginalLikelihood(model, num_samples=1)(
+        test_data, *args, **kwargs
+    )
+    analytic_eif_at_test_pts = 2 * (torch.exp(log_marginal_prob_at_points) - plug_in)
+    analytic_correction = analytic_eif_at_test_pts.mean()
+    return analytic_correction, analytic_eif_at_test_pts
+
+
+def analytic_eif_ate_causal_glm(
+    test_data, point_estimates
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Computes the analytic EIF for the ATE for a ``CausalGLM`` model.
+
+    :param test_data: Dictionary containing test data with keys "X", "A", and "Y"
+    :param point_estimates: Estimated parameters of the model with keys "propensity_weights",
+        "outcome_weights", "treatment_weight", and "intercept"
+    :type point_estimates: _type_
+    :return: Tuple of the analytic EIF averaged over test,
+        and the analytic EIF evaluated pointwise at each test point
+    :rtype: Tuple[torch.Tensor, torch.Tensor]
+    """
+    assert "propensity_weights" in point_estimates, "propensity_weights not found"
+    assert "outcome_weights" in point_estimates, "outcome_weights not found"
+    assert "treatment_weight" in point_estimates, "treatment_weight not found"
+    assert "intercept" in point_estimates, "treatment_weight not found"
+    assert test_data.keys() == {"X", "A", "Y"}, "test_data has unexpected keys"
+
+    X = test_data["X"]
+    A = test_data["A"]
+    Y = test_data["Y"]
+    pi_X = torch.sigmoid(X.mv(point_estimates["propensity_weights"]))
+    mu_X = (
+        X.mv(point_estimates["outcome_weights"])
+        + A * point_estimates["treatment_weight"]
+        + point_estimates["intercept"]
+    )
+    analytic_eif_at_test_pts = (A / pi_X - (1 - A) / (1 - pi_X)) * (Y - mu_X)
+    analytic_correction = analytic_eif_at_test_pts.mean()
+    return analytic_correction, analytic_eif_at_test_pts
diff --git a/docs/examples/robust_paper/finite_difference_eif/__init__.py b/docs/examples/robust_paper/finite_difference_eif/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/docs/examples/robust_paper/finite_difference_eif/abstractions.py b/docs/examples/robust_paper/finite_difference_eif/abstractions.py
new file mode 100644
index 00000000..64dbb82b
--- /dev/null
+++ b/docs/examples/robust_paper/finite_difference_eif/abstractions.py
@@ -0,0 +1,174 @@
+import torch
+import pyro
+import pyro.distributions as dist
+from typing import Dict, Optional
+from contextlib import contextmanager
+from chirho.robust.ops import Point, T
+import numpy as np
+
+
+class ModelWithMarginalDensity(torch.nn.Module):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def density(self, *args, **kwargs):
+        # TODO this can probably default to using BatchedNMCLogMarginalLikelihood applied to self,
+        #  but providing here to avail of analytic densities. Or have a constructor that takes a
+        #  regular model and puts the marginal density here.
+        raise NotImplementedError()
+
+    def forward(self, *args, **kwargs):
+        raise NotImplementedError()
+
+
+class PrefixMessenger(pyro.poutine.messenger.Messenger):
+
+    def __init__(self, prefix: str):
+        self.prefix = prefix
+
+    def _pyro_sample(self, msg) -> None:
+        msg["name"] = f"{self.prefix}{msg['name']}"
+
+
+class FDModelFunctionalDensity(ModelWithMarginalDensity):
+    """
+    This class serves to couple the forward sampling model, density, and functional. Finite differencing
+     operates in the space of densities, and therefore requires of its functionals that they "know about"
+     the causal structure of the generative model. Thus, the three components are coupled together here.
+
+    """
+
+    model: ModelWithMarginalDensity
+
+    # TODO These managers are weird but lets you define a valid model at init time and then temporarily
+    #  modify the perturbation later, eg. in the influence function approximatoin.
+    # TODO pull out boilerplate
+    @contextmanager
+    def set_eps(self, eps):
+        original_eps = self._eps
+        self._eps = eps
+        try:
+            yield
+        finally:
+            self._eps = original_eps
+
+    @contextmanager
+    def set_lambda(self, lambda_):
+        original_lambda = self._lambda
+        self._lambda = lambda_
+        try:
+            yield
+        finally:
+            self._lambda = original_lambda
+
+    @contextmanager
+    def set_kernel_point(self, kernel_point: Dict):
+        original_kernel_point = self._kernel_point
+        self._kernel_point = kernel_point
+        try:
+            yield
+        finally:
+            self._kernel_point = original_kernel_point
+
+    @property
+    def kernel(self) -> ModelWithMarginalDensity:
+        # TODO implementation of a kernel could be brought up to this level. User would need to pass a kernel type
+        #  that's parameterized by the kernel point and lambda.
+        """
+        Inheritors should construct the kernel here as a function of self._kernel_point and self._lambda.
+        :return:
+        """
+        raise NotImplementedError()
+
+    def __init__(self, default_kernel_point: Dict, *args, default_eps=0., default_lambda=0.1, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._eps = default_eps
+        self._lambda = default_lambda
+        self._kernel_point = default_kernel_point
+        # TODO don't assume .shape[-1]
+        self.ndims = np.sum([v.shape[-1] for v in self._kernel_point.values()])
+
+    @property
+    def mixture_weights(self):
+        return torch.tensor([1. - self._eps, self._eps])
+
+    def density(self, model_kwargs: Dict, kernel_kwargs: Dict):
+        mpart = self.mixture_weights[0] * self.model.density(**model_kwargs)
+        kpart = self.mixture_weights[1] * self.kernel.density(**kernel_kwargs)
+        return mpart + kpart
+
+    def forward(self, model_kwargs: Optional[Dict] = None, kernel_kwargs: Optional[Dict] = None):
+        # _from_kernel = pyro.sample('_mixture_assignment', dist.Categorical(self.mixture_weights))
+        #
+        # if _from_kernel:
+        #     return self.kernel(**(kernel_kwargs or dict()))
+        # else:
+        #     return self.model(**(model_kwargs or dict()))
+
+        _from_kernel = pyro.sample('_mixture_assignment', dist.Categorical(self.mixture_weights))
+
+        kernel_mask = _from_kernel.bool()  # Convert to boolean mask
+
+        # Apply the respective functions using the masks
+        with PrefixMessenger('kernel_'), pyro.poutine.trace() as kernel_tr:
+            kernel_result = self.kernel(**(kernel_kwargs or dict()))
+        with PrefixMessenger('model_'), pyro.poutine.trace() as model_tr:
+            model_result = self.model(**(model_kwargs or dict()))
+
+        # FIXME to make log likelihoods work properly, the log likelihoods need to be masked/not added
+        #  for particular elements. See e.g. MaskedMixture for a non-general example of how to do this (it
+        #  uses torch distributions instead of arbitrary probabilistic programs.
+        # https://docs.pyro.ai/en/stable/distributions.html?highlight=MaskedMixture#maskedmixture
+        # FIXME ideally the trace would have elements of the same name as well here.
+
+        # FIXME where isn't shape agnostic.
+
+        # Use masks to select the appropriate result for each sample
+        result = torch.where(kernel_mask[:, None], kernel_result, model_result)
+
+        return result
+
+    def functional(self, *args, **kwargs):
+        # TODO update docstring to this being build_functional instead of just functional
+        """
+        The functional target for this model. This is tightly coupled to a particular
+         pyro model because finite differencing operates in the space of densities, and
+         automatically exploit any structure of the pyro model the functional
+         is being evaluated with respect to. As such, the functional must be implemented
+         with the specific structure of coupled pyro model in mind.
+        :param args:
+        :param kwargs:
+        :return: An estimate of the functional for ths model.
+        """
+        raise NotImplementedError()
+
+
+# TODO move this to chirho/robust/ops.py and resolve signature mismatches? Maybe. The problem is that the ops
+#  signature (rightly) decouples models and functionals, whereas for finite differencing they must be coupled
+#  because the functional (in many cases) must know about the causal structure of the model.
+def fd_influence_fn(fd_coupling: FDModelFunctionalDensity, points: Point[T], eps: float, lambda_: float):
+
+    def _influence_fn(*args, **kwargs):
+
+        # Length of first value in points mappping.
+        len_points = len(list(points.values())[0])
+        eif_vals = []
+        for i in range(len_points):
+            kernel_point = {k: v[i] for k, v in points.items()}
+
+            # Evaluate the original functional.
+            psi_p = fd_coupling.functional(*args, **kwargs)
+
+            # Evaluate the functional of the perturbation.
+            with (fd_coupling.set_eps(eps),
+                  fd_coupling.set_lambda(lambda_),
+                  fd_coupling.set_kernel_point(kernel_point)):
+                psi_p_eps = fd_coupling.functional(*args, **kwargs)
+
+            # Record the finite difference.
+            eif_vals.append((psi_p_eps - psi_p) / eps)
+        return eif_vals
+
+    return _influence_fn
+
+
diff --git a/docs/examples/robust_paper/finite_difference_eif/distributions.py b/docs/examples/robust_paper/finite_difference_eif/distributions.py
new file mode 100644
index 00000000..f9564526
--- /dev/null
+++ b/docs/examples/robust_paper/finite_difference_eif/distributions.py
@@ -0,0 +1,34 @@
+from .abstractions import ModelWithMarginalDensity, FDModelFunctionalDensity
+from scipy.stats import multivariate_normal
+import pyro
+import pyro.distributions as dist
+
+
+class MultivariateNormalwDensity(ModelWithMarginalDensity):
+
+    def __init__(self, mean, scale_tril, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.mean = mean
+        self.scale_tril = scale_tril
+
+        # Convert scale_tril to a covariance matrix.
+        self.cov = scale_tril @ scale_tril.T
+
+    def density(self, x):
+        return multivariate_normal.pdf(x, mean=self.mean, cov=self.cov)
+
+    def forward(self):
+        return pyro.sample("x", dist.MultivariateNormal(self.mean, scale_tril=self.scale_tril))
+
+
+class PerturbableNormal(FDModelFunctionalDensity):
+
+    def __init__(self, *args, mean, scale_tril, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.ndims = mean.shape[-1]
+        self.model = MultivariateNormalwDensity(
+            mean=mean,
+            scale_tril=scale_tril
+        )
diff --git a/docs/examples/robust_paper/finite_difference_eif/mixins.py b/docs/examples/robust_paper/finite_difference_eif/mixins.py
new file mode 100644
index 00000000..22c0adab
--- /dev/null
+++ b/docs/examples/robust_paper/finite_difference_eif/mixins.py
@@ -0,0 +1,56 @@
+from .abstractions import FDModelFunctionalDensity
+import numpy as np
+from scipy.integrate import nquad
+import torch
+import pyro
+from .distributions import MultivariateNormalwDensity
+
+
+class ExpectedDensityQuadFunctional(FDModelFunctionalDensity):
+    """
+    Compute the squared normal density using quadrature.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def functional(self):
+        def integrand(*args):
+            # TODO agnostic to kwarg names.
+            model_kwargs = kernel_kwargs = dict(x=np.array(args))
+            return self.density(model_kwargs, kernel_kwargs) ** 2
+
+        ndim = self._kernel_point['x'].shape[-1]
+
+        return nquad(integrand, [[-np.inf, np.inf]] * ndim)[0]
+
+
+class ExpectedDensityMCFunctional(FDModelFunctionalDensity):
+    """
+    Compute the squared normal density using Monte Carlo.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def functional(self, nmc=1000):
+        # TODO agnostic to kwarg names
+        with pyro.plate('samples', nmc):
+            points = self()
+        return torch.mean(self.density(model_kwargs=dict(x=points), kernel_kwargs=dict(x=points)))
+
+
+class NormalKernel(FDModelFunctionalDensity):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @property
+    def kernel(self):
+        # TODO agnostic to names.
+        mean = self._kernel_point['x']
+        cov = torch.eye(self.ndims) * self._lambda
+        return MultivariateNormalwDensity(
+            mean=mean,
+            scale_tril=torch.linalg.cholesky(cov)
+        )
diff --git a/docs/examples/robust_paper/functionals.py b/docs/examples/robust_paper/functionals.py
new file mode 100644
index 00000000..19130c73
--- /dev/null
+++ b/docs/examples/robust_paper/functionals.py
@@ -0,0 +1,62 @@
+from typing import Callable
+import math
+import torch
+import pyro
+from chirho.counterfactual.handlers import MultiWorldCounterfactual
+from chirho.indexed.ops import IndexSet, gather
+from chirho.interventional.handlers import do
+from chirho.robust.handlers.predictive import PredictiveFunctional
+from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood
+
+pyro.settings.set(module_local_params=True)
+
+
+class ATEFunctional(torch.nn.Module):
+    def __init__(
+        self, model: Callable, *, treatment_name: str = "A", num_monte_carlo: int = 1000
+    ):
+        super().__init__()
+        self.model = model
+        self.num_monte_carlo = num_monte_carlo
+        self.treatment_name = treatment_name
+
+    def forward(self, *args, **kwargs) -> torch.Tensor:
+        """
+        Computes the average treatment effect (ATE) of the model. Assumes that the treatment
+        is binary and that the model returns the target response.
+
+        :return: average treatment effect estimated using Monte Carlo
+        :rtype: torch.Tensor
+        """
+        with MultiWorldCounterfactual():
+            with pyro.plate(
+                "monte_carlo_functional", size=self.num_monte_carlo, dim=-2
+            ):
+                treatment_dict = {
+                    self.treatment_name: (torch.tensor(0.0), torch.tensor(1.0))
+                }
+                with do(actions=treatment_dict):
+                    Ys = self.model(*args, **kwargs)
+                Y0 = gather(Ys, IndexSet(A={1}), event_dim=0)
+                Y1 = gather(Ys, IndexSet(A={2}), event_dim=0)
+        # TODO: if response is scalar, we do we need to average over dim=-1?
+        ate = (Y1 - Y0).mean(dim=-2, keepdim=True).mean(dim=-1, keepdim=True).squeeze()
+        return pyro.deterministic("ATE", ate)
+
+
+class ExpectedDensity(torch.nn.Module):
+    def __init__(self, model, *, num_monte_carlo: int = 10000):
+        super().__init__()
+        self.model = model
+        self.log_marginal_prob = BatchedNMCLogMarginalLikelihood(model, num_samples=1)
+        self.num_monte_carlo = num_monte_carlo
+
+    def forward(self, *args, **kwargs):
+        with pyro.plate("monte_carlo_functional", self.num_monte_carlo):
+            points = PredictiveFunctional(self.model)(*args, **kwargs)
+
+        log_marginal_prob_at_points = self.log_marginal_prob(points, *args, **kwargs)
+        return torch.exp(
+            torch.logsumexp(log_marginal_prob_at_points, dim=0)
+            - math.log(self.num_monte_carlo)
+        )
diff --git a/docs/examples/robust_paper/models.py b/docs/examples/robust_paper/models.py
new file mode 100644
index 00000000..c1346892
--- /dev/null
+++ b/docs/examples/robust_paper/models.py
@@ -0,0 +1,192 @@
+from typing import Callable, Optional, Dict
+import torch
+import math
+import pyro
+import pyro.distributions as dist
+
+pyro.settings.set(module_local_params=True)
+
+
+class CausalGLM(pyro.nn.PyroModule):
+    def __init__(
+        self,
+        p: int,
+        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),
+        prior_scale: Optional[float] = None,
+    ):
+        super().__init__()
+        self.p = p
+        self.link_fn = link_fn
+        if prior_scale is None:
+            self.prior_scale = 1 / math.sqrt(self.p)
+        else:
+            self.prior_scale = prior_scale
+
+        self.observed_sites = ["X", "A", "Y"]
+
+    def sample_outcome_weights(self):
+        return pyro.sample(
+            "outcome_weights",
+            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),
+        )
+
+    def sample_intercept(self):
+        return pyro.sample("intercept", dist.Normal(0.0, 1.0))
+
+    def sample_propensity_weights(self):
+        return pyro.sample(
+            "propensity_weights",
+            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),
+        )
+
+    def sample_treatment_weight(self):
+        return pyro.sample("treatment_weight", dist.Normal(0.0, 1.0))
+
+    def sample_covariate_loc_scale(self):
+        return torch.zeros(self.p), torch.ones(self.p)
+
+    def forward(self):
+        intercept = self.sample_intercept()
+        outcome_weights = self.sample_outcome_weights()
+        propensity_weights = self.sample_propensity_weights()
+        tau = self.sample_treatment_weight()
+        x_loc, x_scale = self.sample_covariate_loc_scale()
+        X = pyro.sample("X", dist.Normal(x_loc, x_scale).to_event(1))
+        A = pyro.sample(
+            "A",
+            dist.Bernoulli(
+                logits=torch.einsum("...i,...i->...", X, propensity_weights)
+            ),
+        )
+
+        return pyro.sample(
+            "Y",
+            self.link_fn(
+                torch.einsum("...i,...i->...", X, outcome_weights) + A * tau + intercept
+            ),
+        )
+
+
+class ConditionedCausalGLM(CausalGLM):
+    def __init__(
+        self,
+        data: Dict[str, torch.Tensor],
+        *,
+        p: int,
+        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),
+        prior_scale: Optional[float] = None,
+    ):
+        assert data["X"].shape[1] == p
+        super().__init__(p, link_fn, prior_scale)
+        self.X = data["X"]
+        self.A = data["A"]
+        self.Y = data["Y"]
+
+    def forward(self):
+        intercept = self.sample_intercept()
+        outcome_weights = self.sample_outcome_weights()
+        propensity_weights = self.sample_propensity_weights()
+        tau = self.sample_treatment_weight()
+        x_loc, x_scale = self.sample_covariate_loc_scale()
+        with pyro.plate("__train__", size=self.X.shape[0], dim=-1):
+            X = pyro.sample("X", dist.Normal(x_loc, x_scale).to_event(1), obs=self.X)
+            A = pyro.sample(
+                "A",
+                dist.Bernoulli(
+                    logits=torch.einsum("ni,i->n", self.X, propensity_weights)
+                ),
+                obs=self.A,
+            )
+            pyro.sample(
+                "Y",
+                self.link_fn(
+                    torch.einsum("ni,i->n", X, outcome_weights) + A * tau + intercept
+                ),
+                obs=self.Y,
+            )
+
+
+class DataGeneratorCausalGLM(CausalGLM):
+    def __init__(
+        self,
+        p: int,
+        alpha: int,
+        beta: int,
+        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),
+        treatment_weight: float = 0.0,
+    ):
+        super().__init__(p, link_fn)
+        self.alpha = alpha  # sparsity of propensity weights
+        self.beta = beta  # sparsity of outcome weights
+        self.treatment_weight = treatment_weight
+
+    def sample_outcome_weights(self):
+        outcome_weights = 1 / math.sqrt(self.beta) * torch.ones(self.p)
+        outcome_weights[self.beta :] = 0.0
+        return outcome_weights
+
+    def sample_propensity_weights(self):
+        propensity_weights = 1 / math.sqrt(self.alpha) * torch.ones(self.p)
+        propensity_weights[self.alpha :] = 0.0
+        return propensity_weights
+
+    def sample_treatment_weight(self):
+        return torch.tensor(self.treatment_weight)
+
+    def sample_intercept(self):
+        return torch.tensor(0.0)
+
+
+class MultivariateNormalModel(pyro.nn.PyroModule):
+    def __init__(self, p: int):
+        super().__init__()
+        self.p = p
+        self.observed_sites = ["x"]
+
+    def sample_mean(self):
+        return pyro.sample("mu", dist.Normal(0.0, 1.0).expand((self.p,)).to_event(1))
+
+    def sample_scale_tril(self):
+        if self.p > 1:
+            return pyro.sample("scale_tril", dist.LKJCholesky(self.p))
+        else:
+            return pyro.sample(
+                "scale_tril", dist.HalfNormal(1.0).expand((self.p, self.p)).to_event(1)
+            )
+
+    def forward(self) -> torch.Tensor:
+        mu = self.sample_mean()
+        scale_tril = self.sample_scale_tril()
+        return pyro.sample("x", dist.MultivariateNormal(loc=mu, scale_tril=scale_tril))
+
+
+class ConditionedMultivariateNormalModel(MultivariateNormalModel):
+    def __init__(self, data: Dict[str, torch.Tensor], *, p: int):
+        super().__init__(p)
+        self.x = data["x"]
+
+    def forward(self):
+        mu = self.sample_mean()
+        scale_tril = self.sample_scale_tril()
+        with pyro.plate("__train__", size=self.x.shape[0], dim=-1):
+            pyro.sample(
+                "x",
+                dist.MultivariateNormal(loc=mu, scale_tril=scale_tril),
+                obs=self.x,
+            )
+
+
+class DataGeneratorMultivariateNormalModel(MultivariateNormalModel):
+    def sample_mean(self):
+        return torch.zeros(self.p)
+
+    def sample_scale_tril(self):
+        return torch.eye(self.p)
+
+
+class kernel_ridge:
+    pass
+
+
+class neural_network:
+    pass
diff --git a/docs/examples/robust_paper/notebooks/error_vs_dimension.ipynb b/docs/examples/robust_paper/notebooks/error_vs_dimension.ipynb
new file mode 100644
index 00000000..c0b45e78
--- /dev/null
+++ b/docs/examples/robust_paper/notebooks/error_vs_dimension.ipynb
@@ -0,0 +1,549 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Callable, Optional, Tuple\n",
+    "from fractions import Fraction\n",
+    "\n",
+    "import functools\n",
+    "import torch\n",
+    "import math\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time\n",
+    "\n",
+    "import pyro\n",
+    "import pyro.distributions as dist\n",
+    "from pyro.infer import Predictive\n",
+    "import pyro.contrib.gp as gp\n",
+    "\n",
+    "from chirho.counterfactual.handlers import MultiWorldCounterfactual\n",
+    "from chirho.indexed.ops import IndexSet, gather\n",
+    "from chirho.interventional.handlers import do\n",
+    "from chirho.robust.internals.utils import ParamDict\n",
+    "from chirho.robust.handlers.estimators import one_step_corrected_estimator \n",
+    "from chirho.robust.ops import influence_fn\n",
+    "from chirho.robust.handlers.predictive import PredictiveModel, PredictiveFunctional\n",
+    "from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood\n",
+    "\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "pyro.set_rng_seed(32891) # for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CausalGLM(pyro.nn.PyroModule):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        p: int,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        prior_scale: Optional[float] = None,\n",
+    "    ):\n",
+    "        super().__init__()\n",
+    "        self.p = p\n",
+    "        self.link_fn = link_fn\n",
+    "        if prior_scale is None:\n",
+    "            self.prior_scale = 1 / math.sqrt(self.p)\n",
+    "        else:\n",
+    "            self.prior_scale = prior_scale\n",
+    "\n",
+    "    def sample_outcome_weights(self):\n",
+    "        return pyro.sample(\n",
+    "            \"outcome_weights\",\n",
+    "            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),\n",
+    "        )\n",
+    "\n",
+    "    def sample_intercept(self):\n",
+    "        return pyro.sample(\"intercept\", dist.Normal(0.0, 1.0))\n",
+    "\n",
+    "    def sample_propensity_weights(self):\n",
+    "        return pyro.sample(\n",
+    "            \"propensity_weights\",\n",
+    "            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),\n",
+    "        )\n",
+    "\n",
+    "    def sample_treatment_weight(self):\n",
+    "        return pyro.sample(\"treatment_weight\", dist.Normal(0.0, 1.0))\n",
+    "\n",
+    "    def sample_covariate_loc_scale(self):\n",
+    "        return torch.zeros(self.p), torch.ones(self.p)\n",
+    "\n",
+    "    def forward(self):\n",
+    "        intercept = self.sample_intercept()\n",
+    "        outcome_weights = self.sample_outcome_weights()\n",
+    "        propensity_weights = self.sample_propensity_weights()\n",
+    "        tau = self.sample_treatment_weight()\n",
+    "        x_loc, x_scale = self.sample_covariate_loc_scale()\n",
+    "        X = pyro.sample(\"X\", dist.Normal(x_loc, x_scale).to_event(1))\n",
+    "        A = pyro.sample(\n",
+    "            \"A\",\n",
+    "            dist.Bernoulli(\n",
+    "                logits=torch.einsum(\"...i,...i->...\", X, propensity_weights)\n",
+    "            ),\n",
+    "        )\n",
+    "\n",
+    "        return pyro.sample(\n",
+    "            \"Y\",\n",
+    "            self.link_fn(\n",
+    "                torch.einsum(\"...i,...i->...\", X, outcome_weights) + A * tau + intercept\n",
+    "            ),\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ConditionedCausalGLM(CausalGLM):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        X: torch.Tensor,\n",
+    "        A: torch.Tensor,\n",
+    "        Y: torch.Tensor,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        prior_scale: Optional[float] = None,\n",
+    "    ):\n",
+    "        p = X.shape[1]\n",
+    "        super().__init__(p, link_fn, prior_scale)\n",
+    "        self.X = X\n",
+    "        self.A = A\n",
+    "        self.Y = Y\n",
+    "\n",
+    "    def forward(self):\n",
+    "        intercept = self.sample_intercept()\n",
+    "        outcome_weights = self.sample_outcome_weights()\n",
+    "        propensity_weights = self.sample_propensity_weights()\n",
+    "        tau = self.sample_treatment_weight()\n",
+    "        x_loc, x_scale = self.sample_covariate_loc_scale()\n",
+    "        with pyro.plate(\"__train__\", size=self.X.shape[0], dim=-1):\n",
+    "            X = pyro.sample(\"X\", dist.Normal(x_loc, x_scale).to_event(1), obs=self.X)\n",
+    "            A = pyro.sample(\n",
+    "                \"A\",\n",
+    "                dist.Bernoulli(\n",
+    "                    logits=torch.einsum(\"ni,i->n\", self.X, propensity_weights)\n",
+    "                ),\n",
+    "                obs=self.A,\n",
+    "            )\n",
+    "            pyro.sample(\n",
+    "                \"Y\",\n",
+    "                self.link_fn(\n",
+    "                    torch.einsum(\"ni,i->n\", X, outcome_weights)\n",
+    "                    + A * tau\n",
+    "                    + intercept\n",
+    "                ),\n",
+    "                obs=self.Y,\n",
+    "            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GroundTruthModel(CausalGLM):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        p: int,\n",
+    "        alpha: int,\n",
+    "        beta: int,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        treatment_weight: float = 0.0,\n",
+    "    ):\n",
+    "        super().__init__(p, link_fn)\n",
+    "        self.alpha = alpha  # sparsity of propensity weights\n",
+    "        self.beta = beta  # sparsity of outcome weights\n",
+    "        self.treatment_weight = treatment_weight\n",
+    "\n",
+    "    def sample_outcome_weights(self):\n",
+    "        outcome_weights = 1 / math.sqrt(self.beta) * torch.ones(self.p)\n",
+    "        outcome_weights[self.beta :] = 0.0\n",
+    "        return outcome_weights\n",
+    "\n",
+    "    def sample_propensity_weights(self):\n",
+    "        propensity_weights = 1 / math.sqrt(self.alpha) * torch.ones(self.p)\n",
+    "        propensity_weights[self.alpha :] = 0.0\n",
+    "        return propensity_weights\n",
+    "\n",
+    "    def sample_treatment_weight(self):\n",
+    "        return torch.tensor(self.treatment_weight)\n",
+    "\n",
+    "    def sample_intercept(self):\n",
+    "        return torch.tensor(0.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "simulated_datasets = []\n",
+    "\n",
+    "# Data configuration\n",
+    "alpha = 50\n",
+    "beta = 50\n",
+    "N_train = 500\n",
+    "N_test = 50\n",
+    "p_grid = [1, 10, 25, 50, 100, 150, 200, 250, 300, 500]\n",
+    "\n",
+    "for p_dim in p_grid:\n",
+    "    true_model = GroundTruthModel(p_dim, alpha, beta)\n",
+    "\n",
+    "    # Generate data\n",
+    "    D_train = Predictive(\n",
+    "        true_model, num_samples=N_train, return_sites=[\"X\", \"A\", \"Y\"]\n",
+    "    )()\n",
+    "    D_test = Predictive(\n",
+    "        true_model, num_samples=N_test, return_sites=[\"X\", \"A\", \"Y\"]\n",
+    "    )()\n",
+    "    simulated_datasets.append((D_train, D_test))\n",
+    "\n",
+    "N_datasets = len(simulated_datasets)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fitted_params = []\n",
+    "model_fitting_time = []\n",
+    "for i in range(N_datasets):\n",
+    "    # Generate data\n",
+    "    D_train = simulated_datasets[i][0]\n",
+    "\n",
+    "    start = time.time()\n",
+    "    # Fit model using maximum likelihood\n",
+    "    conditioned_model = ConditionedCausalGLM(\n",
+    "        X=D_train[\"X\"], A=D_train[\"A\"], Y=D_train[\"Y\"]\n",
+    "    )\n",
+    "    \n",
+    "    guide_train = pyro.infer.autoguide.AutoDelta(conditioned_model)\n",
+    "    elbo = pyro.infer.Trace_ELBO()(conditioned_model, guide_train)\n",
+    "\n",
+    "    # initialize parameters\n",
+    "    elbo()\n",
+    "    adam = torch.optim.Adam(elbo.parameters(), lr=0.03)\n",
+    "\n",
+    "    # Do gradient steps\n",
+    "    for _ in range(2000):\n",
+    "        adam.zero_grad()\n",
+    "        loss = elbo()\n",
+    "        loss.backward()\n",
+    "        adam.step()\n",
+    "\n",
+    "    model_fitting_time.append(time.time() - start)\n",
+    "\n",
+    "    theta_hat = {\n",
+    "        k: v.clone().detach().requires_grad_(True) for k, v in guide_train().items()\n",
+    "    }\n",
+    "    fitted_params.append(theta_hat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "10\n",
+      "25\n",
+      "50\n",
+      "100\n",
+      "150\n",
+      "200\n",
+      "250\n",
+      "300\n",
+      "500\n"
+     ]
+    }
+   ],
+   "source": [
+    "class ATEFunctional(torch.nn.Module):\n",
+    "    def __init__(self, model: Callable, *, num_monte_carlo: int = 100):\n",
+    "        super().__init__()\n",
+    "        self.model = model\n",
+    "        self.num_monte_carlo = num_monte_carlo\n",
+    "    \n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        with MultiWorldCounterfactual():\n",
+    "            with pyro.plate(\"monte_carlo_functional\", size=self.num_monte_carlo, dim=-2):\n",
+    "                with do(actions=dict(A=(torch.tensor(0.0), torch.tensor(1.0)))):\n",
+    "                    Ys = self.model(*args, **kwargs)\n",
+    "                Y0 = gather(Ys, IndexSet(A={1}), event_dim=0)\n",
+    "                Y1 = gather(Ys, IndexSet(A={2}), event_dim=0)\n",
+    "        ate = (Y1 - Y0).mean(dim=-2, keepdim=True).mean(dim=-1, keepdim=True).squeeze()\n",
+    "        return pyro.deterministic(\"ATE\", ate)\n",
+    "    \n",
+    "# Closed form expression\n",
+    "def closed_form_doubly_robust_ate_correction(X_test, theta) -> Tuple[torch.Tensor, torch.Tensor]:\n",
+    "    X = X_test[\"X\"]\n",
+    "    A = X_test[\"A\"]\n",
+    "    Y = X_test[\"Y\"]\n",
+    "    pi_X = torch.sigmoid(X.mv(theta[\"propensity_weights\"]))\n",
+    "    mu_X = (\n",
+    "        X.mv(theta[\"outcome_weights\"])\n",
+    "        + A * theta[\"treatment_weight\"]\n",
+    "        + theta[\"intercept\"]\n",
+    "    )\n",
+    "    analytic_eif_at_test_pts = (A / pi_X - (1 - A) / (1 - pi_X)) * (Y - mu_X)\n",
+    "    analytic_correction = analytic_eif_at_test_pts.mean()\n",
+    "    return analytic_correction, analytic_eif_at_test_pts\n",
+    "\n",
+    "# Helper class to create a trivial guide that returns the maximum likelihood estimate\n",
+    "class MLEGuide(torch.nn.Module):\n",
+    "    def __init__(self, mle_est: ParamDict):\n",
+    "        super().__init__()\n",
+    "        self.names = list(mle_est.keys())\n",
+    "        for name, value in mle_est.items():\n",
+    "            setattr(self, name + \"_param\", torch.nn.Parameter(value))\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        for name in self.names:\n",
+    "            value = getattr(self, name + \"_param\")\n",
+    "            pyro.sample(\n",
+    "                name, pyro.distributions.Delta(value, event_dim=len(value.shape))\n",
+    "            )\n",
+    "\n",
+    "# Compute doubly robust ATE estimates using both the automated and closed form expressions\n",
+    "plug_in_ates = []\n",
+    "analytic_corrections = []\n",
+    "automated_monte_carlo_corrections = []\n",
+    "automated_monte_carlo_at_test = []\n",
+    "automated_monte_carlo_time = []\n",
+    "analytic_at_test = []\n",
+    "for i, p in enumerate(p_grid):\n",
+    "    print(p)\n",
+    "    theta_hat = fitted_params[i]\n",
+    "    D_test = simulated_datasets[i][1]\n",
+    "    mle_guide = MLEGuide(theta_hat)\n",
+    "    functional = functools.partial(ATEFunctional, num_monte_carlo=10000)\n",
+    "    ate_plug_in = functional(\n",
+    "        PredictiveModel(CausalGLM(p), mle_guide)\n",
+    "    )()\n",
+    "    analytic_correction, analytic_eif_at_test_pts = closed_form_doubly_robust_ate_correction(D_test, theta_hat)\n",
+    "\n",
+    "    start = time.time()\n",
+    "    monte_eif = influence_fn(functional, D_test, num_samples_outer=10000, num_samples_inner=1)\n",
+    "    monte_eif_at_test_pts = monte_eif(PredictiveModel(CausalGLM(p), mle_guide))()\n",
+    "    end = time.time()\n",
+    "    automated_monte_carlo_time.append(end - start)\n",
+    "    automated_monte_carlo_at_test.append(monte_eif_at_test_pts)\n",
+    "    analytic_at_test.append(analytic_eif_at_test_pts)\n",
+    "\n",
+    "    plug_in_ates.append(ate_plug_in.detach().item())\n",
+    "    analytic_corrections.append(ate_plug_in.detach().item() + analytic_correction.detach().item())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def median_rel_error(x, y):\n",
+    "    x = torch.tensor(x)\n",
+    "    y = torch.tensor(y)\n",
+    "    return torch.median(torch.abs(x - y) / torch.abs(y))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/1n/rv21b_n10gx0tp5_zz33z7qc0000gn/T/ipykernel_55710/3392044420.py:2: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  x = torch.tensor(x)\n",
+      "/var/folders/1n/rv21b_n10gx0tp5_zz33z7qc0000gn/T/ipykernel_55710/3392044420.py:3: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  y = torch.tensor(y)\n"
+     ]
+    }
+   ],
+   "source": [
+    "monte_eif_errors = [median_rel_error(monte_eif_at_test_pts, analytic_eif_at_test_pts) for monte_eif_at_test_pts, analytic_eif_at_test_pts in zip(automated_monte_carlo_at_test, analytic_at_test)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_dimension_grid = [sum([v.numel() for k, v in param.items()]) for param in fitted_params]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Fraction(7, 16)"
+      ]
+     },
+     "execution_count": 68,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Fraction(int(round(16*obs_slope)),16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "obs_slope, obs_intercept = np.polyfit(\n",
+    "    np.log10(model_dimension_grid), \n",
+    "    np.log10(monte_eif_errors), 1)\n",
+    "\n",
+    "theory_slope = 1/2\n",
+    "theory_intercept = (np.log10(monte_eif_errors) - theory_slope * np.log10(model_dimension_grid)).mean()\n",
+    "\n",
+    "# Plot results\n",
+    "plt.plot(\n",
+    "    model_dimension_grid, \n",
+    "    monte_eif_errors, \n",
+    "    label='Monte Carlo EIF (10k Monte Carlo samples)', \n",
+    "    color='#154c79',\n",
+    "    marker='o'\n",
+    ")\n",
+    "obs_rate_num = Fraction(int(round(8*obs_slope)),8).numerator\n",
+    "obs_rate_denom = Fraction(int(round(8*obs_slope)),8).denominator\n",
+    "plt.plot(model_dimension_grid, \n",
+    "    10**obs_intercept * np.power(model_dimension_grid, obs_slope), \n",
+    "    label='Est. Error Rate: O($p^{7/16}$)',\n",
+    "    color='red',\n",
+    "    linestyle='--'\n",
+    ")\n",
+    "plt.plot(model_dimension_grid, \n",
+    "    10**theory_intercept * np.power(model_dimension_grid, theory_slope), \n",
+    "    label='Our Theory: O($p^{1/2}$)',\n",
+    "    color='green',\n",
+    "    linestyle='--'\n",
+    ")\n",
+    "plt.xscale('log')\n",
+    "plt.yscale('log')\n",
+    "plt.ylabel('Median Relative Error', fontsize=18)\n",
+    "plt.xlabel('Model Dimension (p)', fontsize=18)\n",
+    "sns.despine()\n",
+    "plt.legend(fontsize=13, frameon=False)\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('./figures/error_rate_causal_glm_vs_dim.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot results\n",
+    "plt.plot(\n",
+    "    model_dimension_grid, \n",
+    "    automated_monte_carlo_time, \n",
+    "    label='Monte Carlo EIF (10k Monte Carlo samples)', \n",
+    "    color='#154c79',\n",
+    "    marker='o'\n",
+    ")\n",
+    "plt.plot(\n",
+    "    model_dimension_grid, \n",
+    "    model_fitting_time, \n",
+    "    label='Model Fitting Time', \n",
+    "    color='#f95d6a',\n",
+    "    marker='o'\n",
+    "\n",
+    ")\n",
+    "# plt.xscale('log')\n",
+    "# plt.yscale('log')\n",
+    "plt.ylabel('Runtime (s)', fontsize=18)\n",
+    "plt.xlabel('Model Dimension', fontsize=18)\n",
+    "sns.despine()\n",
+    "plt.legend(fontsize=13, frameon=False)\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('./figures/runtime_causal_glm_vs_dim.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "basis",
+   "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/examples/robust_paper/notebooks/expected_density.ipynb b/docs/examples/robust_paper/notebooks/expected_density.ipynb
new file mode 100644
index 00000000..56e8a5af
--- /dev/null
+++ b/docs/examples/robust_paper/notebooks/expected_density.ipynb
@@ -0,0 +1,711 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import time\n",
+    "import math\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import pyro\n",
+    "import pyro.distributions as dist\n",
+    "from pyro.infer import Predictive\n",
+    "from chirho.robust.internals.utils import ParamDict\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "sns.set_style(\"white\")\n",
+    "pyro.set_rng_seed(321)  # for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ToyNormal(pyro.nn.PyroModule):\n",
+    "    def forward(self):\n",
+    "        mu = pyro.sample(\"mu\", dist.Normal(0.0, 1.0))\n",
+    "        sd = pyro.sample(\"sd\", dist.HalfNormal(1.0))\n",
+    "        return pyro.sample(\n",
+    "            \"Y\",\n",
+    "            dist.Normal(mu, scale=sd),\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "class ToyNormalKnownSD(pyro.nn.PyroModule):\n",
+    "    def __init__(self, sd_true):\n",
+    "        super().__init__()\n",
+    "        self.sd_true = sd_true\n",
+    "    def forward(self):\n",
+    "        mu = pyro.sample(\"mu\", dist.Normal(0.0, 1.0))\n",
+    "        sd = pyro.sample(\"sd\", dist.HalfNormal(1.0))\n",
+    "        return pyro.sample(\n",
+    "            \"Y\",\n",
+    "            dist.Normal(mu, scale=self.sd_true),\n",
+    "        )\n",
+    "\n",
+    "class GroundTruthToyNormal(pyro.nn.PyroModule):\n",
+    "    def __init__(self, mu_true, sd_true):\n",
+    "        super().__init__()\n",
+    "        self.mu_true = mu_true\n",
+    "        self.sd_true = sd_true\n",
+    "    def forward(self):\n",
+    "        return pyro.sample(\n",
+    "            \"Y\",\n",
+    "            dist.Normal(self.mu_true, scale=self.sd_true),\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "normal_pdf = lambda x, mu, sd: torch.exp(-0.5 * ((x - mu) / sd) ** 2) / (sd * math.sqrt(2.0 * math.pi))\n",
+    "normal_pdf_partial_sd = torch.func.grad(normal_pdf, argnums=2)\n",
+    "\n",
+    "\n",
+    "def fisher_eif_analytic(Y, mu, sd, known_sd):\n",
+    "    assert isinstance(mu, float)\n",
+    "    assert isinstance(sd, float)\n",
+    "    if known_sd:\n",
+    "        return torch.zeros(Y.shape[0])\n",
+    "    else:\n",
+    "        sd_torch = torch.tensor(sd, requires_grad=True)\n",
+    "        z_monte = sd * torch.randn(10000) + mu\n",
+    "        grad_functional = 2 * torch.tensor([normal_pdf_partial_sd(z, mu, sd_torch) for z in z_monte]).mean()\n",
+    "        inverse_fisher = sd ** 2 / 2\n",
+    "        score = ((Y - mu) ** 2) / (sd ** 3) - 1/sd\n",
+    "    return grad_functional * inverse_fisher * score\n",
+    "\n",
+    "\n",
+    "def kennedy_if_analytic(Y, mu, sd):\n",
+    "    assert isinstance(mu, float)\n",
+    "    assert isinstance(sd, float)\n",
+    "    pdf_at_y = normal_pdf(Y, mu, sd)\n",
+    "    z_monte = sd * torch.randn(100000)\n",
+    "    expected_density = torch.tensor([normal_pdf(z, mu, sd) for z in z_monte]).mean()\n",
+    "    return 2 * (pdf_at_y - expected_density)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Analytic Influence Function & Efficient Influence Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N_pts = 500\n",
+    "mu_true = 0.0\n",
+    "sd_true = 1.0\n",
+    "true_model = GroundTruthToyNormal(mu_true, sd_true)\n",
+    "D_pts = Predictive(true_model, num_samples=N_pts, return_sites=[\"Y\"])()\n",
+    "Y_pts = D_pts[\"Y\"]\n",
+    "Y_pts = torch.sort(Y_pts).values\n",
+    "\n",
+    "fisher_pointwise = fisher_eif_analytic(Y_pts, mu_true, sd_true, False)\n",
+    "kennedy_pointwise = kennedy_if_analytic(Y_pts, mu_true, sd_true)\n",
+    "tangent_fn_pointwise = kennedy_pointwise - fisher_pointwise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "plt.plot(Y_pts, torch.zeros(Y_pts.shape[0]), label=\"Efficient Influence (Known SD)\")\n",
+    "plt.plot(Y_pts, fisher_pointwise, label=\"Efficient Influence (Unknown SD)\")\n",
+    "plt.plot(Y_pts, kennedy_pointwise, label=\"Nonparametric Influence\")\n",
+    "plt.plot(Y_pts, tangent_fn_pointwise, label=\"Tangent Nuisance Function\")\n",
+    "plt.xlabel('Value of x', fontsize=18)\n",
+    "plt.ylabel('Influence Function at x', fontsize=18)\n",
+    "plt.legend(fontsize=13)\n",
+    "sns.despine()\n",
+    "plt.savefig(\"figures/toy_normal_influence_functions.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor(0.0004)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This should be close to zero since the tangent nuisance function is orthogonal to the efficient influence function\n",
+    "fisher_pointwise.dot(tangent_fn_pointwise) / N_pts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Compare Analytic w/ Automated Influnce Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import functools\n",
+    "from chirho.robust.ops import influence_fn\n",
+    "from chirho.robust.handlers.predictive import PredictiveModel, PredictiveFunctional\n",
+    "from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MLEGuide(torch.nn.Module):\n",
+    "    def __init__(self, mle_est: ParamDict):\n",
+    "        super().__init__()\n",
+    "        self.names = list(mle_est.keys())\n",
+    "        for name, value in mle_est.items():\n",
+    "            setattr(self, name + \"_param\", torch.nn.Parameter(value))\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        for name in self.names:\n",
+    "            value = getattr(self, name + \"_param\")\n",
+    "            pyro.sample(\n",
+    "                name, pyro.distributions.Delta(value, event_dim=len(value.shape))\n",
+    "            )\n",
+    "            \n",
+    "class ExpectedDensity(torch.nn.Module):\n",
+    "    def __init__(self, model, *, num_monte_carlo: int = 10000):\n",
+    "        super().__init__()\n",
+    "        self.model = model\n",
+    "        self.log_marginal_prob = BatchedNMCLogMarginalLikelihood(model, num_samples=1)\n",
+    "        self.num_monte_carlo = num_monte_carlo\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        with pyro.plate(\"monte_carlo_functional\", self.num_monte_carlo):\n",
+    "            points = PredictiveFunctional(self.model)(*args, **kwargs)\n",
+    "\n",
+    "        log_marginal_prob_at_points = self.log_marginal_prob(points, *args, **kwargs)\n",
+    "        return torch.exp(\n",
+    "            torch.logsumexp(log_marginal_prob_at_points, dim=0)\n",
+    "            - math.log(self.num_monte_carlo)\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "functional = functools.partial(ExpectedDensity, num_monte_carlo=10000)\n",
+    "\n",
+    "theta_true = {\n",
+    "    \"mu\": torch.tensor(mu_true, requires_grad=True), \n",
+    "    \"sd\": torch.tensor(sd_true, requires_grad=True)\n",
+    "}\n",
+    "\n",
+    "model = ToyNormal()\n",
+    "guide = MLEGuide(theta_true)\n",
+    "\n",
+    "monte_eif = influence_fn(\n",
+    "    functional, {'Y': Y_pts}, num_samples_outer=50000, num_samples_inner=1\n",
+    ")(PredictiveModel(model, guide))()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Uknown Mean, Unknown SD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(Y_pts, fisher_pointwise, label='Analytic EIF', color='black')\n",
+    "plt.scatter(Y_pts, monte_eif.detach().numpy(), label='Monte Carlo EIF', alpha=.5)\n",
+    "plt.xlabel('Value of x', fontsize=18)\n",
+    "plt.ylabel('Influence Function at x', fontsize=18)\n",
+    "plt.legend(fontsize=13)\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"figures/toy_normal_monte_carlo_eif_unknown_var.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Uknown Mean, Known SD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "functional = functools.partial(ExpectedDensity, num_monte_carlo=10000)\n",
+    "\n",
+    "theta_true = {\n",
+    "    \"mu\": torch.tensor(mu_true, requires_grad=True), \n",
+    "}\n",
+    "\n",
+    "model = ToyNormalKnownSD(sd_true)\n",
+    "guide = MLEGuide(theta_true)\n",
+    "\n",
+    "monte_eif = influence_fn(\n",
+    "    functional, {'Y': Y_pts}, num_samples_outer=50000, num_samples_inner=1\n",
+    ")(PredictiveModel(model, guide))()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(Y_pts, torch.zeros(Y_pts.shape[0]), label='Analytic EIF', color='black')\n",
+    "plt.scatter(Y_pts, monte_eif.detach().numpy(), label='Monte Carlo EIF', alpha=.5)\n",
+    "plt.xlabel('Value of x', fontsize=18)\n",
+    "plt.ylabel('Influence Function at x', fontsize=18)\n",
+    "plt.legend(fontsize=13)\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"figures/toy_normal_monte_carlo_eif_known_var.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Finite-Difference Smoothed Gateaux Approach"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append(\"../scripts/\")\n",
+    "from fd_influence_approx import (\n",
+    "    compute_fd_correction_sqd_mvn_mc,\n",
+    "    compute_fd_correction_sqd_mvn_quad\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/finite_difference_eif/distributions.py:16: UserWarning: The use of `x.T` on tensors of dimension other than 2 to reverse their shape is deprecated and it will throw an error in a future release. Consider `x.mT` to transpose batches of matrices or `x.permute(*torch.arange(x.ndim - 1, -1, -1))` to reverse the dimensions of a tensor. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/native/TensorShape.cpp:3618.)\n",
+      "  self.cov = scale_tril @ scale_tril.T\n"
+     ]
+    }
+   ],
+   "source": [
+    "theta_true = {\n",
+    "    \"mu\": torch.tensor(mu_true, requires_grad=True).unsqueeze(0), \n",
+    "    \"scale_tril\": torch.tensor(sd_true, requires_grad=True).unsqueeze(0)\n",
+    "}\n",
+    "\n",
+    "\n",
+    "fd_quad_kwargs = {\n",
+    "    \"lambdas\": [.05, .01, .005],\n",
+    "    \"epss\": [.05, .01, .005],\n",
+    "    \"num_samples_scaling\": 10,\n",
+    "    \"seed\": 0,\n",
+    "}\n",
+    "\n",
+    "fd_quad_eif_results = compute_fd_correction_sqd_mvn_quad(\n",
+    "    theta_hat=theta_true,\n",
+    "    test_data={'x': Y_pts.unsqueeze(-1)},\n",
+    "    **fd_quad_kwargs\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x1200 with 9 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot 3 x 3 grid of results\n",
+    "fig, axes = plt.subplots(3, 3, figsize=(12, 12))\n",
+    "for iter, result in enumerate(fd_quad_eif_results):\n",
+    "        i = iter // 3\n",
+    "        j = iter % 3\n",
+    "        epsilon = fd_quad_kwargs[\"epss\"][i]\n",
+    "        lam = fd_quad_kwargs[\"lambdas\"][j]\n",
+    "        axes[i, j].scatter(Y_pts, result['pointwise'], label='FD Smoothed Gateaux', color='#eab676')\n",
+    "        axes[i, j].plot(Y_pts, kennedy_pointwise, label='Nonparametric Influence', color='black')\n",
+    "        axes[i, j].set_xlabel('Value of x', fontsize=15)\n",
+    "        axes[i, j].set_ylabel('Influence Function at x', fontsize=15)\n",
+    "        axes[i, j].set_title(f\"$\\epsilon$={epsilon}, $\\lambda$={lam}\", fontsize=15)\n",
+    "        axes[i, j].legend(frameon=False)\n",
+    "        sns.despine()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"./figures/expected_density_gateaux_grid.png\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Runtime vs. Quality"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'fd_quad_eif_results' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb Cell 22\u001b[0m line \u001b[0;36m6\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X45sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m     y \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mtensor(y)\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X45sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m torch\u001b[39m.\u001b[39mmedian(torch\u001b[39m.\u001b[39mabs(x \u001b[39m-\u001b[39m y) \u001b[39m/\u001b[39m torch\u001b[39m.\u001b[39mabs(y))\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X45sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m fd_quad_rel_mae \u001b[39m=\u001b[39m [median_rel_error(result[\u001b[39m'\u001b[39m\u001b[39mpointwise\u001b[39m\u001b[39m'\u001b[39m], kennedy_pointwise) \u001b[39mfor\u001b[39;00m result \u001b[39min\u001b[39;00m fd_quad_eif_results]\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X45sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m fd_quad_time \u001b[39m=\u001b[39m [result[\u001b[39m'\u001b[39m\u001b[39mwall_time\u001b[39m\u001b[39m'\u001b[39m] \u001b[39mfor\u001b[39;00m result \u001b[39min\u001b[39;00m fd_quad_eif_results]\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'fd_quad_eif_results' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "def median_rel_error(x, y):\n",
+    "    x = torch.tensor(x)\n",
+    "    y = torch.tensor(y)\n",
+    "    return torch.median(torch.abs(x - y) / torch.abs(y))\n",
+    "\n",
+    "fd_quad_rel_mae = [median_rel_error(result['pointwise'], kennedy_pointwise) for result in fd_quad_eif_results]\n",
+    "fd_quad_time = [result['wall_time'] for result in fd_quad_eif_results]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/1n/rv21b_n10gx0tp5_zz33z7qc0000gn/T/ipykernel_53328/3498049407.py:2: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  x = torch.tensor(x)\n",
+      "/var/folders/1n/rv21b_n10gx0tp5_zz33z7qc0000gn/T/ipykernel_53328/3498049407.py:3: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  y = torch.tensor(y)\n"
+     ]
+    }
+   ],
+   "source": [
+    "monte_eif_size = []\n",
+    "monte_eif_errors = []\n",
+    "monte_eif_runtimes = []\n",
+    "for n_monte in [10, 100, 1000, 10000, 100000]:\n",
+    "    start = time.time()\n",
+    "    functional = functools.partial(ExpectedDensity, num_monte_carlo=n_monte)\n",
+    "    theta_true = {\n",
+    "        \"mu\": torch.tensor(mu_true, requires_grad=True), \n",
+    "        \"sd\": torch.tensor(sd_true, requires_grad=True)\n",
+    "    }\n",
+    "\n",
+    "    model = ToyNormal()\n",
+    "    guide = MLEGuide(theta_true)\n",
+    "    monte_eif = influence_fn(\n",
+    "        functional, {'Y': Y_pts}, num_samples_outer=n_monte, num_samples_inner=1\n",
+    "    )(PredictiveModel(model, guide))()\n",
+    "    end = time.time()\n",
+    "    monte_eif_runtimes.append(end - start)\n",
+    "    monte_eif_errors.append(median_rel_error(monte_eif, fisher_pointwise))\n",
+    "    monte_eif_size.append(n_monte)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'fd_quad_time' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb Cell 24\u001b[0m line \u001b[0;36m2\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X61sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m plt\u001b[39m.\u001b[39mscatter(monte_eif_runtimes, monte_eif_errors, label\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mMonte Carlo EIF\u001b[39m\u001b[39m'\u001b[39m, color\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mblue\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X61sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m plt\u001b[39m.\u001b[39mscatter(fd_quad_time, fd_quad_rel_mae, label\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mFD Smoothed Gateaux\u001b[39m\u001b[39m'\u001b[39m, color\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39m#eab676\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X61sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m'\u001b[39m\u001b[39mWall Time (s)\u001b[39m\u001b[39m'\u001b[39m, fontsize\u001b[39m=\u001b[39m\u001b[39m18\u001b[39m)\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X61sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m plt\u001b[39m.\u001b[39mylabel(\u001b[39m'\u001b[39m\u001b[39mMedian Relative Error\u001b[39m\u001b[39m'\u001b[39m, fontsize\u001b[39m=\u001b[39m\u001b[39m18\u001b[39m)\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'fd_quad_time' is not defined"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plt.scatter(monte_eif_runtimes, monte_eif_errors, label='Monte Carlo EIF', color='blue')\n",
+    "# plt.scatter(fd_quad_time, fd_quad_rel_mae, label='FD Smoothed Gateaux', color='#eab676')\n",
+    "# plt.xlabel('Wall Time (s)', fontsize=18)\n",
+    "# plt.ylabel('Median Relative Error', fontsize=18)\n",
+    "# # plt.xscale('log')\n",
+    "# # plt.yscale('log')\n",
+    "# plt.legend(fontsize=12)\n",
+    "# sns.despine()\n",
+    "# plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(\n",
+    "    monte_eif_size, \n",
+    "    monte_eif_errors, \n",
+    "    label='Monte Carlo EIF', \n",
+    "    color='#154c79',\n",
+    "    marker='o'\n",
+    ")\n",
+    "plt.xscale('log')\n",
+    "plt.yscale('log')\n",
+    "plt.ylabel('Median Relative Error', fontsize=18)\n",
+    "plt.xlabel('Number of Monte Carlo EIF Samples', fontsize=18)\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"./figures/monte_carlo_eif_samples_vs_error_expected_density.png\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "base_dist = dist.Normal(torch.tensor(0.0), torch.tensor(1.0))\n",
+    "dist_y = dist.TransformedDistribution(base_dist, [pyro.distributions.transforms.ExpTransform()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'TransformedDistribution' object has no attribute 'params'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[1;32m/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb Cell 27\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#X66sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m dist_y\u001b[39m.\u001b[39;49mparams\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'TransformedDistribution' object has no attribute 'params'"
+     ]
+    }
+   ],
+   "source": [
+    "dist_y."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# class NormalizingFlowModel(pyro.nn.PyroModule):\n",
+    "#     def __init__(self):\n",
+    "#         self.base_dist = dist.Normal(0, 1)\n",
+    "#         self.exp_transform = dist.transforms.ExpTransform()\n",
+    "\n",
+    "#     def forward():\n",
+    "#         return pyro.sample(\"Y\", dist.TransformedDistribution(self.base_dist, [self.exp_transform]))\n",
+    "\n",
+    "base_dist = dist.Normal(torch.zeros(10), torch.ones(10))\n",
+    "\n",
+    "\n",
+    "class NormalizingFlowLikelihood(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        # self.base_dist = torch.distributions.normal.Normal(torch.tensor([0]), torch.tensor([1]))\n",
+    "        self.base_dist = dist.Normal(torch.tensor(0.0), torch.tensor(1.0)).expand([1])\n",
+    "        self.arn = pyro.nn.AutoRegressiveNN(1, [40], param_dims=[16]*3)\n",
+    "        self.transform = dist.transforms.NeuralAutoregressive(self.arn, hidden_units=16)\n",
+    "        # self.transform = dist.transforms.ExpTransform()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return dist.TransformedDistribution(self.base_dist, [self.transform]).log_prob(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/pyro/nn/auto_reg_nn.py:179: UserWarning: ConditionalAutoRegressiveNN input_dim = 1. Consider using an affine transformation instead.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "ename": "NotImplementedError",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
+      "\u001b[1;32m/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb Cell 29\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#Y112sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m NormalizingFlowLikelihood()(torch\u001b[39m.\u001b[39;49mtensor([[\u001b[39m1\u001b[39;49m]]))\n",
+      "File \u001b[0;32m/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/torch/nn/modules/module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1516\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_compiled_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)  \u001b[39m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1517\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m-> 1518\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call_impl(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n",
+      "File \u001b[0;32m/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/torch/nn/modules/module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1522\u001b[0m \u001b[39m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1523\u001b[0m \u001b[39m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1524\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_pre_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1525\u001b[0m         \u001b[39mor\u001b[39;00m _global_backward_pre_hooks \u001b[39mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1526\u001b[0m         \u001b[39mor\u001b[39;00m _global_forward_hooks \u001b[39mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0m     \u001b[39mreturn\u001b[39;00m forward_call(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m   1529\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m   1530\u001b[0m     result \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n",
+      "\u001b[1;32m/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb Cell 29\u001b[0m line \u001b[0;36m2\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#Y112sZmlsZQ%3D%3D?line=20'>21</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mforward\u001b[39m(\u001b[39mself\u001b[39m, x):\n\u001b[0;32m---> <a href='vscode-notebook-cell:/Users/raj/Desktop/causal_pyro/docs/examples/robust_paper/notebooks/expected_density.ipynb#Y112sZmlsZQ%3D%3D?line=21'>22</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m dist\u001b[39m.\u001b[39;49mTransformedDistribution(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mbase_dist, [\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtransform])\u001b[39m.\u001b[39;49mlog_prob(x)\n",
+      "File \u001b[0;32m/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/torch/distributions/transformed_distribution.py:168\u001b[0m, in \u001b[0;36mTransformedDistribution.log_prob\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m    166\u001b[0m y \u001b[39m=\u001b[39m value\n\u001b[1;32m    167\u001b[0m \u001b[39mfor\u001b[39;00m transform \u001b[39min\u001b[39;00m \u001b[39mreversed\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtransforms):\n\u001b[0;32m--> 168\u001b[0m     x \u001b[39m=\u001b[39m transform\u001b[39m.\u001b[39;49minv(y)\n\u001b[1;32m    169\u001b[0m     event_dim \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m transform\u001b[39m.\u001b[39mdomain\u001b[39m.\u001b[39mevent_dim \u001b[39m-\u001b[39m transform\u001b[39m.\u001b[39mcodomain\u001b[39m.\u001b[39mevent_dim\n\u001b[1;32m    170\u001b[0m     log_prob \u001b[39m=\u001b[39m log_prob \u001b[39m-\u001b[39m _sum_rightmost(\n\u001b[1;32m    171\u001b[0m         transform\u001b[39m.\u001b[39mlog_abs_det_jacobian(x, y),\n\u001b[1;32m    172\u001b[0m         event_dim \u001b[39m-\u001b[39m transform\u001b[39m.\u001b[39mdomain\u001b[39m.\u001b[39mevent_dim,\n\u001b[1;32m    173\u001b[0m     )\n",
+      "File \u001b[0;32m/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/torch/distributions/transforms.py:262\u001b[0m, in \u001b[0;36m_InverseTransform.__call__\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    260\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__call__\u001b[39m(\u001b[39mself\u001b[39m, x):\n\u001b[1;32m    261\u001b[0m     \u001b[39massert\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_inv \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m--> 262\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inv\u001b[39m.\u001b[39;49m_inv_call(x)\n",
+      "File \u001b[0;32m/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/torch/distributions/transforms.py:173\u001b[0m, in \u001b[0;36mTransform._inv_call\u001b[0;34m(self, y)\u001b[0m\n\u001b[1;32m    171\u001b[0m \u001b[39mif\u001b[39;00m y \u001b[39mis\u001b[39;00m y_old:\n\u001b[1;32m    172\u001b[0m     \u001b[39mreturn\u001b[39;00m x_old\n\u001b[0;32m--> 173\u001b[0m x \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inverse(y)\n\u001b[1;32m    174\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_cached_x_y \u001b[39m=\u001b[39m x, y\n\u001b[1;32m    175\u001b[0m \u001b[39mreturn\u001b[39;00m x\n",
+      "File \u001b[0;32m/opt/homebrew/anaconda3/envs/basis/lib/python3.10/site-packages/torch/distributions/transforms.py:187\u001b[0m, in \u001b[0;36mTransform._inverse\u001b[0;34m(self, y)\u001b[0m\n\u001b[1;32m    183\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_inverse\u001b[39m(\u001b[39mself\u001b[39m, y):\n\u001b[1;32m    184\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    185\u001b[0m \u001b[39m    Abstract method to compute inverse transformation.\u001b[39;00m\n\u001b[1;32m    186\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 187\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m\n",
+      "\u001b[0;31mNotImplementedError\u001b[0m: "
+     ]
+    },
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click <a href='https://aka.ms/vscodeJupyterKernelCrash'>here</a> for more info. View Jupyter <a href='command:jupyter.viewOutput'>log</a> for further details."
+     ]
+    }
+   ],
+   "source": [
+    "NormalizingFlowLikelihood()(torch.tensor([[1]]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "basis",
+   "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/examples/robust_paper/notebooks/figures/causal_glm_performance_vs_estimator.png b/docs/examples/robust_paper/notebooks/figures/causal_glm_performance_vs_estimator.png
new file mode 100644
index 00000000..a5240fe8
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/causal_glm_performance_vs_estimator.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/causal_glm_performance_vs_estimator_just_doubleml.png b/docs/examples/robust_paper/notebooks/figures/causal_glm_performance_vs_estimator_just_doubleml.png
new file mode 100644
index 00000000..e622a649
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/causal_glm_performance_vs_estimator_just_doubleml.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/double_convergence_causal_glm.png b/docs/examples/robust_paper/notebooks/figures/double_convergence_causal_glm.png
new file mode 100644
index 00000000..e2a14146
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/double_convergence_causal_glm.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/error_rate_causal_glm_vs_dim.png b/docs/examples/robust_paper/notebooks/figures/error_rate_causal_glm_vs_dim.png
new file mode 100644
index 00000000..bc93cb57
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/error_rate_causal_glm_vs_dim.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/expected_density_gateaux_grid.png b/docs/examples/robust_paper/notebooks/figures/expected_density_gateaux_grid.png
new file mode 100644
index 00000000..c5263e6d
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/expected_density_gateaux_grid.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/markowitz_optimal.png b/docs/examples/robust_paper/notebooks/figures/markowitz_optimal.png
new file mode 100644
index 00000000..5c52a1e0
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/markowitz_optimal.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/monte_carlo_eif_samples_vs_error_expected_density.png b/docs/examples/robust_paper/notebooks/figures/monte_carlo_eif_samples_vs_error_expected_density.png
new file mode 100644
index 00000000..0f07fe2f
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/monte_carlo_eif_samples_vs_error_expected_density.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/one_step_convergence_causal_glm.png b/docs/examples/robust_paper/notebooks/figures/one_step_convergence_causal_glm.png
new file mode 100644
index 00000000..458289e9
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/one_step_convergence_causal_glm.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/runtime_causal_glm_vs_dim.png b/docs/examples/robust_paper/notebooks/figures/runtime_causal_glm_vs_dim.png
new file mode 100644
index 00000000..670a22a3
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/runtime_causal_glm_vs_dim.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/tmle_convergence_causal_glm.png b/docs/examples/robust_paper/notebooks/figures/tmle_convergence_causal_glm.png
new file mode 100644
index 00000000..fd709e40
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/tmle_convergence_causal_glm.png differ
diff --git a/docs/examples/robust_paper/notebooks/figures/toy_normal_influence_functions.pdf b/docs/examples/robust_paper/notebooks/figures/toy_normal_influence_functions.pdf
new file mode 100644
index 00000000..99e121bc
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/toy_normal_influence_functions.pdf differ
diff --git a/docs/examples/robust_paper/notebooks/figures/toy_normal_monte_carlo_eif_known_var.pdf b/docs/examples/robust_paper/notebooks/figures/toy_normal_monte_carlo_eif_known_var.pdf
new file mode 100644
index 00000000..8db54fcb
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/toy_normal_monte_carlo_eif_known_var.pdf differ
diff --git a/docs/examples/robust_paper/notebooks/figures/toy_normal_monte_carlo_eif_unknown_var.pdf b/docs/examples/robust_paper/notebooks/figures/toy_normal_monte_carlo_eif_unknown_var.pdf
new file mode 100644
index 00000000..cbfaa51c
Binary files /dev/null and b/docs/examples/robust_paper/notebooks/figures/toy_normal_monte_carlo_eif_unknown_var.pdf differ
diff --git a/docs/examples/robust_paper/notebooks/optimization_functional.ipynb b/docs/examples/robust_paper/notebooks/optimization_functional.ipynb
new file mode 100644
index 00000000..35f048f4
--- /dev/null
+++ b/docs/examples/robust_paper/notebooks/optimization_functional.ipynb
@@ -0,0 +1,815 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Robust estimation with optimization functionals with Chirho"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we install the necessary Pytorch, Pyro, and ChiRho dependencies for this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "NOTE: Redirects are currently not supported in Windows or MacOs.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from typing import Callable, Optional, Tuple\n",
+    "\n",
+    "import functools\n",
+    "import torch\n",
+    "import math\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torchopt\n",
+    "\n",
+    "import pyro\n",
+    "import pyro.distributions as dist\n",
+    "from pyro.infer import Predictive\n",
+    "import pyro.contrib.gp as gp\n",
+    "\n",
+    "from chirho.counterfactual.handlers import MultiWorldCounterfactual\n",
+    "from chirho.indexed.ops import IndexSet, gather\n",
+    "from chirho.interventional.handlers import do\n",
+    "from chirho.robust.internals.utils import ParamDict\n",
+    "from chirho.robust.handlers.estimators import one_step_corrected_estimator, tmle\n",
+    "from chirho.robust.ops import influence_fn\n",
+    "from chirho.robust.handlers.predictive import PredictiveModel, PredictiveFunctional\n",
+    "from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood\n",
+    "\n",
+    "from docs.examples.robust_paper.models import MultivariateNormalModel\n",
+    "\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "\n",
+    "sns.set_style(\"white\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ZeroCenteredModel(MultivariateNormalModel):\n",
+    "    def forward(self):\n",
+    "        scale_tril = self.sample_scale_tril()\n",
+    "        pyro.sample(\"x\", dist.MultivariateNormal(loc=torch.zeros(self.p), scale_tril=scale_tril))\n",
+    "\n",
+    "        return scale_tril\n",
+    "    \n",
+    "class KnownCovModel(ZeroCenteredModel):\n",
+    "    def __init__(self, p, scale_tril):\n",
+    "        super().__init__(p)\n",
+    "        self.scale_tril = scale_tril\n",
+    "\n",
+    "    def sample_scale_tril(self):\n",
+    "        return self.scale_tril\n",
+    "    \n",
+    "class ConditionedModel(ZeroCenteredModel):\n",
+    "    def __init__(self, D_train, include_prior=True):\n",
+    "        self.D_train = D_train\n",
+    "        self.N, p = D_train['x'].shape\n",
+    "        self.include_prior = include_prior\n",
+    "        super().__init__(p)\n",
+    "    \n",
+    "    def forward(self):\n",
+    "        with pyro.poutine.mask(mask=self.include_prior):\n",
+    "            scale_tril = self.sample_scale_tril()\n",
+    "        with pyro.condition(data=self.D_train):\n",
+    "            with pyro.plate(self.N, dim=-2):\n",
+    "                pyro.sample(\"x\", dist.MultivariateNormal(loc=torch.zeros(self.p), scale_tril=scale_tril))\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Data configuration\n",
+    "p = 25\n",
+    "alpha = 50\n",
+    "beta = 50\n",
+    "N_train = 500\n",
+    "N_test = 500\n",
+    "\n",
+    "# TODO: set this manually\n",
+    "pyro.set_rng_seed(0)\n",
+    "true_scale_tril = pyro.sample(\"scale_tril\", dist.LKJCholesky(p))\n",
+    "# true_scale_tril = torch.eye(p)\n",
+    "\n",
+    "true_model = KnownCovModel(p, true_scale_tril)\n",
+    "\n",
+    "def generate_data(N_train, N_test):\n",
+    "    # Generate data\n",
+    "    D_train = Predictive(\n",
+    "        true_model, num_samples=N_train, return_sites=[\"x\"]\n",
+    "    )()\n",
+    "    D_test = Predictive(\n",
+    "        true_model, num_samples=N_test, return_sites=[\"x\"]\n",
+    "    )()\n",
+    "    return D_train, D_test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fit parameters via maximum likelihood"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def MLE(D_train, n_steps=1000, include_prior=True):\n",
+    "    # Fit model using maximum likelihood\n",
+    "    conditioned_model = ConditionedModel(D_train, include_prior=include_prior)\n",
+    "    \n",
+    "    guide_train = pyro.infer.autoguide.AutoDelta(conditioned_model)\n",
+    "    elbo = pyro.infer.Trace_ELBO()(conditioned_model, guide_train)\n",
+    "\n",
+    "    # initialize parameters\n",
+    "    elbo()\n",
+    "    adam = torch.optim.Adam(elbo.parameters(), lr=0.03)\n",
+    "\n",
+    "    # Do gradient steps\n",
+    "    for _ in range(n_steps):\n",
+    "        adam.zero_grad()\n",
+    "        loss = elbo()\n",
+    "        loss.backward()\n",
+    "        adam.step()\n",
+    "\n",
+    "    theta_hat = {\n",
+    "        k: v.clone().detach().requires_grad_(True) for k, v in guide_train().items()\n",
+    "    }\n",
+    "    return theta_hat"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the target functional"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper class to create a trivial guide that returns the maximum likelihood estimate\n",
+    "class MLEGuide(torch.nn.Module):\n",
+    "    def __init__(self, mle_est: ParamDict):\n",
+    "        super().__init__()\n",
+    "        self.names = list(mle_est.keys())\n",
+    "        for name, value in mle_est.items():\n",
+    "            setattr(self, name + \"_param\", torch.nn.Parameter(value))\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        for name in self.names:\n",
+    "            value = getattr(self, name + \"_param\")\n",
+    "            pyro.sample(\n",
+    "                name, pyro.distributions.Delta(value, event_dim=len(value.shape))\n",
+    "            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MarkowitzFunctional(torch.nn.Module):\n",
+    "    def __init__(self, model):\n",
+    "        super().__init__()\n",
+    "        self.model = model\n",
+    "        \n",
+    "    def forward(self, scale_tril=None):\n",
+    "        if scale_tril is None:\n",
+    "            scale_tril = self.model()\n",
+    "        cov = scale_tril.mm(scale_tril.T)\n",
+    "        cov_inv = torch.inverse(cov)\n",
+    "        one_vec = torch.ones(cov_inv.shape[0])\n",
+    "        num = cov_inv.mv(one_vec)\n",
+    "        den = one_vec.dot(num)\n",
+    "        return num/den\n",
+    "\n",
+    "optimal_weights = MarkowitzFunctional(None)(true_scale_tril)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([ 0.0072,  0.0949,  0.0397,  0.2320,  0.0390, -0.0013, -0.0164,  0.2619,\n",
+       "        -0.0973,  0.1266,  0.1220, -0.0946,  0.2408, -0.0671, -0.0729, -0.0603,\n",
+       "         0.0012,  0.0739, -0.1326, -0.0098, -0.0712,  0.1233,  0.0662,  0.1291,\n",
+       "         0.0655])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "optimal_weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# D_train, D_test = generate_data(N_train, N_test)\n",
+    "\n",
+    "# theta_hat = MLE(D_train)\n",
+    "\n",
+    "# theta_hat = {\n",
+    "#     k: v.clone().detach().requires_grad_(True) for k, v in theta_hat.items()\n",
+    "# }\n",
+    "# mle_guide = MLEGuide(theta_hat)\n",
+    "# model = PredictiveModel(ZeroCenteredModel(p), mle_guide)\n",
+    "\n",
+    "# eif_fn = influence_fn(MarkowitzFunctional, D_test, num_samples_outer=100000, pointwise_influence=False)\n",
+    "# correction_estimator = eif_fn(model)\n",
+    "# correction = correction_estimator()\n",
+    "# correction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Computing automated doubly robust estimators via Monte Carlo\n",
+    "\n",
+    "While the doubly robust correction term is known in closed-form for the average treatment effect functional, our `one_step_correction` and `tmle` function in `ChiRho` works for a wide class of other functionals. We focus on the average treatment effect functional here so that we have a ground truth to compare `one_step_correction` against the plug in estimates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "# Compute doubly robust ATE estimates using both the automated and closed form expressions\n",
+    "N_datasets = 20\n",
+    "\n",
+    "\n",
+    "# Estimators to compare\n",
+    "estimators = {\"one_step\": one_step_corrected_estimator}\n",
+    "estimator_kwargs = {\n",
+    "    \"one_step\": {}\n",
+    "}\n",
+    "\n",
+    "# Influence functions\n",
+    "influences = {\"monte_carlo_eif\": influence_fn}\n",
+    "\n",
+    "# Cache the results\n",
+    "RESULTS_PATH = \"../results/opt_markowitz.json\"\n",
+    "\n",
+    "if os.path.exists(RESULTS_PATH):\n",
+    "    with open(RESULTS_PATH, \"r\") as f:\n",
+    "        estimates = json.load(f)\n",
+    "    i_start = len(estimates[\"plug-in-mle-from-model\"]) \n",
+    "else:\n",
+    "    estimates = {f\"{influence}-{estimator}\": [] for influence in influences.keys() for estimator in estimators.keys()}\n",
+    "    estimates[\"plug-in-mle-from-model\"] = []\n",
+    "    i_start = 0\n",
+    "\n",
+    "# optimization functional of interest\n",
+    "functional = MarkowitzFunctional\n",
+    "\n",
+    "for i in range(i_start, N_datasets):\n",
+    "    pyro.set_rng_seed(i) # for reproducibility\n",
+    "    print(\"Dataset\", i)\n",
+    "    D_train, D_test = generate_data(N_train, N_test)\n",
+    "    theta_hat = MLE(D_train, include_prior=False)\n",
+    "\n",
+    "    theta_hat = {\n",
+    "        k: v.clone().detach().requires_grad_(True) for k, v in theta_hat.items()\n",
+    "    }\n",
+    "    mle_guide = MLEGuide(theta_hat)\n",
+    "    model = PredictiveModel(ZeroCenteredModel(p), mle_guide)\n",
+    "    \n",
+    "    print(\"plug-in-mle-from-model\", i)\n",
+    "    plug_in_estimate = functional(model)().detach()\n",
+    "    plug_in_estimate_list = [e.item() for e in plug_in_estimate]\n",
+    "    estimates[\"plug-in-mle-from-model\"].append(plug_in_estimate_list)\n",
+    "\n",
+    "    for estimator_str, estimator in estimators.items():\n",
+    "        for influence_str, influence in influences.items():\n",
+    "            print(estimator_str, influence_str, i)\n",
+    "            estimate = estimator(\n",
+    "                functional, \n",
+    "                D_test,\n",
+    "                num_samples_outer=max(100000, 100 * p), \n",
+    "                num_samples_inner=1,\n",
+    "                influence_estimator=influence,\n",
+    "                **estimator_kwargs[estimator_str]\n",
+    "            )(PredictiveModel(ZeroCenteredModel(p), mle_guide))().squeeze().detach()\n",
+    "\n",
+    "            # There must be a more concise way...\n",
+    "            estimate_list = [e.item() for e in estimate]\n",
+    "\n",
+    "            estimates[f\"{influence_str}-{estimator_str}\"].append(estimate_list)\n",
+    "\n",
+    "    with open(RESULTS_PATH, \"w\") as f:\n",
+    "        json.dump(estimates, f, indent=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'monte_carlo_eif-one_step': [1.0000000279396772,\n",
+       "  1.0000000838190317,\n",
+       "  0.9999999697320163,\n",
+       "  0.999999935971573,\n",
+       "  1.0000000768341124,\n",
+       "  0.9999999012798071,\n",
+       "  0.9999999338760972,\n",
+       "  0.9999999273568392,\n",
+       "  0.9999999846331775,\n",
+       "  1.0000001098960638,\n",
+       "  1.000000067986548,\n",
+       "  0.9999999878928065,\n",
+       "  1.0000000353902578,\n",
+       "  1.0000000009313226,\n",
+       "  0.9999999874271452,\n",
+       "  0.9999999916180968,\n",
+       "  1.0000000563450158,\n",
+       "  1.0000000125728548,\n",
+       "  1.0000000027939677,\n",
+       "  1.0000000055879354,\n",
+       "  0.9999999664723873,\n",
+       "  1.0000000540167093,\n",
+       "  1.0000000484287739,\n",
+       "  1.000000051688403,\n",
+       "  0.9999999720603228,\n",
+       "  0.9999999473802745,\n",
+       "  0.9999999722931534,\n",
+       "  1.000000017695129,\n",
+       "  0.9999999543651938,\n",
+       "  0.999999986961484,\n",
+       "  1.0000000651925802,\n",
+       "  0.9999999916180968,\n",
+       "  1.0000000479631126,\n",
+       "  1.0000000037252903,\n",
+       "  0.9999999834690243,\n",
+       "  1.000000077765435,\n",
+       "  0.9999999436549842,\n",
+       "  1.0000000318977982,\n",
+       "  1.0000000079162419,\n",
+       "  1.0000000013969839,\n",
+       "  1.0000000884756446,\n",
+       "  0.9999999990686774,\n",
+       "  1.0000001057051122,\n",
+       "  0.9999999965075403,\n",
+       "  0.9999999511055648,\n",
+       "  0.9999999515712261,\n",
+       "  1.0000000726431608,\n",
+       "  0.9999998931307346,\n",
+       "  1.0000000135041773,\n",
+       "  0.9999999506399035],\n",
+       " 'plug-in-mle-from-model': [1.0000000407453626,\n",
+       "  0.9999999039791874,\n",
+       "  1.0000000288709998,\n",
+       "  0.9999999525025487,\n",
+       "  1.0000000833533704,\n",
+       "  0.9999999827705324,\n",
+       "  0.9999999953433871,\n",
+       "  0.9999999031424522,\n",
+       "  0.9999999804422259,\n",
+       "  1.0000000689178705,\n",
+       "  1.0000000819563866,\n",
+       "  1.0000000392901711,\n",
+       "  1.000000013038516,\n",
+       "  1.0000000747386366,\n",
+       "  0.9999998938583303,\n",
+       "  1.0000000484287739,\n",
+       "  0.9999999694991857,\n",
+       "  0.9999999967694748,\n",
+       "  0.9999999317806214,\n",
+       "  0.9999999972060323,\n",
+       "  0.9999999972060323,\n",
+       "  0.9999999718274921,\n",
+       "  0.9999999182764441,\n",
+       "  1.000000049592927,\n",
+       "  0.9999999506399035,\n",
+       "  1.0000000125728548,\n",
+       "  1.0000000051222742,\n",
+       "  1.0000000149011612,\n",
+       "  0.9999999571591616,\n",
+       "  1.0000000093132257,\n",
+       "  1.0000000167638063,\n",
+       "  1.0000000190339051,\n",
+       "  1.0000001061707735,\n",
+       "  1.0000000256113708,\n",
+       "  0.9999998938292265,\n",
+       "  1.0000000060535967,\n",
+       "  0.9999999958090484,\n",
+       "  0.9999999930150807,\n",
+       "  0.9999999487772584,\n",
+       "  0.9999999948777258,\n",
+       "  0.99999997287523,\n",
+       "  0.9999999683350325,\n",
+       "  0.9999999650754035,\n",
+       "  0.9999999587889761,\n",
+       "  0.9999999352730811,\n",
+       "  0.9999999292194843,\n",
+       "  1.0000000656582415,\n",
+       "  0.9999999932479113,\n",
+       "  0.9999999972060323,\n",
+       "  0.999999969266355]}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{k:[sum(v) for v in val] for k, val in estimates.items()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mse(weights, optimal_weights=optimal_weights):\n",
+    "    return ((weights - optimal_weights)**2).mean()\n",
+    "\n",
+    "def mae(weights, optimal_weights=optimal_weights):\n",
+    "    return torch.abs(weights-optimal_weights).mean()\n",
+    "\n",
+    "def relative_root_mse(weights, optimal_weights=optimal_weights):\n",
+    "    return torch.sqrt(((weights - optimal_weights)**2).mean())/torch.sqrt((optimal_weights**2).mean())\n",
+    "\n",
+    "def relative_mae(weights, optimal_weights=optimal_weights):\n",
+    "    return torch.abs(weights-optimal_weights).mean()/torch.abs(optimal_weights).mean()\n",
+    "\n",
+    "def expected_volatility(weights, scale_tril=true_scale_tril):\n",
+    "    return torch.sqrt(weights @ scale_tril @ scale_tril.T @ weights)\n",
+    "\n",
+    "def relative_expected_volatility(weights, scale_tril=true_scale_tril):\n",
+    "    return expected_volatility(weights, scale_tril)/expected_volatility(optimal_weights, scale_tril)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "estimates_mse = {k: torch.tensor([mse(torch.tensor(v)) for v in vals]) for (k, vals) in estimates.items()}\n",
+    "estimates_mae = {k: torch.tensor([mae(torch.tensor(v)) for v in vals]) for (k, vals) in estimates.items()}\n",
+    "estimates_relative_mae = {k: torch.tensor([relative_mae(torch.tensor(v)) for v in vals]) for (k, vals) in estimates.items()}\n",
+    "estimates_relative_root_mse = {k: torch.tensor([relative_root_mse(torch.tensor(v)) for v in vals]) for (k, vals) in estimates.items()}\n",
+    "estimates_expected_volatility = {k: torch.tensor([expected_volatility(torch.tensor(v)) for v in vals]) for (k, vals) in estimates.items()}\n",
+    "estimates_relative_expected_volatility = {k: torch.tensor([relative_expected_volatility(torch.tensor(v)) for v in vals]) for (k, vals) in estimates.items()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EV monte_carlo_eif-one_step    1.86\n",
+      "plug-in-mle-from-model      2.60\n",
+      "dtype: float32 \n",
+      "\n",
+      "RMSE monte_carlo_eif-one_step    0.08\n",
+      "plug-in-mle-from-model      0.14\n",
+      "dtype: float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The true treatment effect is 0, so a mean estimate closer to zero is better\n",
+    "results_1 = pd.DataFrame(estimates_relative_expected_volatility)\n",
+    "results_2 = pd.DataFrame(estimates_relative_root_mse)\n",
+    "\n",
+    "print(\"EV\", results_1.mean().round(2), \"\\n\")\n",
+    "print(\"RMSE\", results_2.mean().round(2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EV monte_carlo_eif-one_step    0.35\n",
+      "plug-in-mle-from-model      0.35\n",
+      "dtype: float32 \n",
+      "\n",
+      "RMSE monte_carlo_eif-one_step    0.02\n",
+      "plug-in-mle-from-model      0.02\n",
+      "dtype: float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"EV\", (results_1.std()/(N_datasets**0.5)).round(2), \"\\n\")\n",
+    "print(\"RMSE\", (results_2.std()/(N_datasets**0.5)).round(2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>monte_carlo_eif-one_step</th>\n",
+       "      <th>plug-in-mle-from-model</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>50.00000</td>\n",
+       "      <td>50.00000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>0.07710</td>\n",
+       "      <td>0.13518</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>0.09951</td>\n",
+       "      <td>0.09249</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>0.00504</td>\n",
+       "      <td>0.02069</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>0.01625</td>\n",
+       "      <td>0.04987</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>0.03924</td>\n",
+       "      <td>0.10729</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>0.08816</td>\n",
+       "      <td>0.21390</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>0.58151</td>\n",
+       "      <td>0.35913</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       monte_carlo_eif-one_step  plug-in-mle-from-model\n",
+       "count                  50.00000                50.00000\n",
+       "mean                    0.07710                 0.13518\n",
+       "std                     0.09951                 0.09249\n",
+       "min                     0.00504                 0.02069\n",
+       "25%                     0.01625                 0.04987\n",
+       "50%                     0.03924                 0.10729\n",
+       "75%                     0.08816                 0.21390\n",
+       "max                     0.58151                 0.35913"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The true treatment effect is 0, so a mean estimate closer to zero is better\n",
+    "results = pd.DataFrame(estimates_relative_root_mse)\n",
+    "results.describe().round(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize the results\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "# # TMLE\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['analytic_eif-tmle'], \n",
+    "#     label=\"Analytic EIF (TMLE)\",\n",
+    "#     ax=ax,\n",
+    "#     color='blue',\n",
+    "#     linestyle='--'\n",
+    "# )\n",
+    "\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['monte_carlo_eif-tmle'], \n",
+    "#     label=\"Monte Carlo EIF (TMLE)\",\n",
+    "#     ax=ax,\n",
+    "#     color='blue'\n",
+    "# )\n",
+    "\n",
+    "# # One-step\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['analytic_eif-one_step'], \n",
+    "#     label=\"Analytic EIF (One-Step)\",\n",
+    "#     ax=ax,\n",
+    "#     color='red',\n",
+    "#     linestyle='--'\n",
+    "# )\n",
+    "\n",
+    "sns.kdeplot(\n",
+    "    estimates_mae['monte_carlo_eif-one_step'], \n",
+    "    label=\"Monte Carlo EIF (One-Step)\",\n",
+    "    ax=ax,\n",
+    "    color='red',\n",
+    "    cut=0\n",
+    ")\n",
+    "\n",
+    "# # DoubleML\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['analytic_eif-double_ml'], \n",
+    "#     label=\"Analytic EIF (DoubleML)\",\n",
+    "#     ax=ax,\n",
+    "#     color='green',\n",
+    "#     linestyle='--'\n",
+    "# )\n",
+    "\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['monte_carlo_eif-double_ml'], \n",
+    "#     label=\"Monte Carlo EIF (DoubleML)\",\n",
+    "#     ax=ax,\n",
+    "#     color='green'\n",
+    "# )\n",
+    "\n",
+    "# Plug-in MLE\n",
+    "sns.kdeplot(\n",
+    "    estimates_mae['plug-in-mle-from-model'], \n",
+    "    label=\"Plug-in MLE\",\n",
+    "    ax=ax,\n",
+    "    color='brown',\n",
+    "    cut=0\n",
+    ")\n",
+    "\n",
+    "ax.set_yticks([])\n",
+    "sns.despine()\n",
+    "ax.set_xlabel(\"MAE in weights\", fontsize=18)\n",
+    "ax.set_ylabel(\"Density\", fontsize=18)\n",
+    "\n",
+    "ax.legend(loc=\"upper right\", fontsize=11)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "plt.savefig('figures/markowitz_optimal.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "Kennedy, Edward. \"Towards optimal doubly robust estimation of heterogeneous causal effects\", 2022. https://arxiv.org/abs/2004.14497."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "basis",
+   "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.11.4"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/examples/robust_paper/notebooks/quality_vs_estimators.ipynb b/docs/examples/robust_paper/notebooks/quality_vs_estimators.ipynb
new file mode 100644
index 00000000..69077287
--- /dev/null
+++ b/docs/examples/robust_paper/notebooks/quality_vs_estimators.ipynb
@@ -0,0 +1,1223 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Automated doubly robust estimation with ChiRho"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Outline\n",
+    "\n",
+    "- [Setup](#setup)\n",
+    "\n",
+    "- [Overview: Systematically adjusting for observed confounding](#overview:-systematically-adjusting-for-observed-confounding)\n",
+    "    - [Task: Treatment effect estimation with observational data](#task:-treatment-effect-estimation-with-observational-data)\n",
+    "    - [Challenge: Confounding](#challenge:-confounding)\n",
+    "    - [Assumptions: All confounders observed](#assumptions:-all-confounders-observed)\n",
+    "    - [Intuition: Statistically adjusting for confounding](#intuition:-statistically-adjusting-for-confounding)\n",
+    "\n",
+    "- [Causal Probabilistic Program](#causal-probabilistic-program)\n",
+    "    - [Model description](#model-description)\n",
+    "    - [Generating data](#generating-data)\n",
+    "    - [Fit parameters via maximum likelihood](#fit-parameters-via-maximum-likelihood)\n",
+    "\n",
+    "- [Causal Query: average treatment effect (ATE)](#causal-query:-average-treatment-effect-\\(ATE\\))\n",
+    "    - [Defining the target functional](#defining-the-target-functional)\n",
+    "    - [Closed form doubly robust correction](#closed-form-doubly-robust-correction)\n",
+    "    - [Computing automated doubly robust estimators via Monte Carlo](#computing-automated-doubly-robust-estimators-via-monte-carlo)\n",
+    "    - [Results](#results)\n",
+    "\n",
+    "- [References](#references)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we install the necessary Pytorch, Pyro, and ChiRho dependencies for this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-robust/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "[2024-10-22 16:13:27,226] torch.distributed.elastic.multiprocessing.redirects: [WARNING] NOTE: Redirects are currently not supported in Windows or MacOs.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from typing import Callable, Optional, Tuple\n",
+    "\n",
+    "import functools\n",
+    "import torch\n",
+    "import math\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import pyro\n",
+    "import pyro.distributions as dist\n",
+    "from pyro.infer import Predictive\n",
+    "import pyro.contrib.gp as gp\n",
+    "\n",
+    "from chirho.counterfactual.handlers import MultiWorldCounterfactual\n",
+    "from chirho.indexed.ops import IndexSet, gather\n",
+    "from chirho.interventional.handlers import do\n",
+    "from chirho.robust.internals.utils import ParamDict\n",
+    "from chirho.robust.handlers.estimators import one_step_corrected_estimator, tmle\n",
+    "from chirho.robust.ops import influence_fn\n",
+    "from chirho.robust.handlers.predictive import PredictiveModel, PredictiveFunctional\n",
+    "from chirho.robust.internals.nmc import BatchedNMCLogMarginalLikelihood\n",
+    "\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "\n",
+    "sns.set_style(\"white\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "\n",
+    "In this tutorial, we will use ChiRho to estimate the average treatment effect (ATE) from observational data. We will use a simple example to illustrate the basic concepts of doubly robust estimation and how ChiRho can be used to automate the process for more general summaries of interest. \n",
+    "\n",
+    "There are five main steps to our doubly robust estimation procedure but only the last step is different from a standard probabilistic programming workflow:\n",
+    "1. Write model of interest\n",
+    "    - Define probabilistic model of interest using Pyro\n",
+    "2. Feed in data\n",
+    "    - Observed data used to train the model\n",
+    "3. Run inference\n",
+    "    - Use Pyro's rich inference library to fit the model to the data\n",
+    "4. Define target functional\n",
+    "    - This is the model summary of interest (e.g. average treatment effect)\n",
+    "5. Compute robust estimate\n",
+    "    - Use ChiRho to compute the doubly robust estimate of the target functional\n",
+    "    - Importantly, this step is automated and does not require refitting the model for each new functional"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Causal Probabilistic Program\n",
+    "\n",
+    "### Model Description\n",
+    "In this example, we will focus on a cannonical model `CausalGLM` consisting of three types of variables: binary treatment (`A`), confounders (`X`), and response (`Y`). For simplicitly, we assume that the response is generated from a generalized linear model with link function $g$. The model is described by the following generative process:\n",
+    "\n",
+    "$$\n",
+    "\\begin{align*}\n",
+    "X &\\sim \\text{Normal}(0, I_p) \\\\\n",
+    "A &\\sim \\text{Bernoulli}(\\pi(X)) \\\\\n",
+    "\\mu &= \\beta_0 + \\beta_1^T X + \\tau A \\\\\n",
+    "Y &\\sim \\text{ExponentialFamily}(\\text{mean} = g^{-1}(\\mu))\n",
+    "\\end{align*}\n",
+    "$$\n",
+    "\n",
+    "where $p$ denotes the number of confounders, $\\pi(X)$ is the probability of treatment conditional on confounders $X$, $\\beta_0$ is the intercept, $\\beta_1$ is the confounder effect, and $\\tau$ is the treatment effect."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CausalGLM(pyro.nn.PyroModule):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        p: int,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        prior_scale: Optional[float] = None,\n",
+    "    ):\n",
+    "        super().__init__()\n",
+    "        self.p = p\n",
+    "        self.link_fn = link_fn\n",
+    "        if prior_scale is None:\n",
+    "            self.prior_scale = 1 / math.sqrt(self.p)\n",
+    "        else:\n",
+    "            self.prior_scale = prior_scale\n",
+    "\n",
+    "    def sample_outcome_weights(self):\n",
+    "        return pyro.sample(\n",
+    "            \"outcome_weights\",\n",
+    "            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),\n",
+    "        )\n",
+    "\n",
+    "    def sample_intercept(self):\n",
+    "        return pyro.sample(\"intercept\", dist.Normal(0.0, 1.0))\n",
+    "\n",
+    "    def sample_propensity_weights(self):\n",
+    "        return pyro.sample(\n",
+    "            \"propensity_weights\",\n",
+    "            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),\n",
+    "        )\n",
+    "\n",
+    "    def sample_treatment_weight(self):\n",
+    "        return pyro.sample(\"treatment_weight\", dist.Normal(0.0, 1.0))\n",
+    "\n",
+    "    def sample_covariate_loc_scale(self):\n",
+    "        return torch.zeros(self.p), torch.ones(self.p)\n",
+    "\n",
+    "    def forward(self):\n",
+    "        intercept = self.sample_intercept()\n",
+    "        outcome_weights = self.sample_outcome_weights()\n",
+    "        propensity_weights = self.sample_propensity_weights()\n",
+    "        tau = self.sample_treatment_weight()\n",
+    "        x_loc, x_scale = self.sample_covariate_loc_scale()\n",
+    "        X = pyro.sample(\"X\", dist.Normal(x_loc, x_scale).to_event(1))\n",
+    "        A = pyro.sample(\n",
+    "            \"A\",\n",
+    "            dist.Bernoulli(\n",
+    "                logits=torch.einsum(\"...i,...i->...\", X, propensity_weights)\n",
+    "            ),\n",
+    "        )\n",
+    "\n",
+    "        return pyro.sample(\n",
+    "            \"Y\",\n",
+    "            self.link_fn(\n",
+    "                torch.einsum(\"...i,...i->...\", X, outcome_weights) + A * tau + intercept\n",
+    "            ),\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we will condition on both treatment and confounders to estimate the causal effect of treatment on the outcome. We will use the following causal probabilistic program to do so:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ConditionedCausalGLM(CausalGLM):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        X: torch.Tensor,\n",
+    "        A: torch.Tensor,\n",
+    "        Y: torch.Tensor,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        prior_scale: Optional[float] = None,\n",
+    "        include_prior: bool = False,\n",
+    "    ):\n",
+    "        p = X.shape[1]\n",
+    "        super().__init__(p, link_fn, prior_scale)\n",
+    "        self.X = X\n",
+    "        self.A = A\n",
+    "        self.Y = Y\n",
+    "        self.include_prior = include_prior \n",
+    "\n",
+    "    def forward(self):\n",
+    "        with pyro.poutine.mask(mask=not self.include_prior):\n",
+    "            intercept = self.sample_intercept()\n",
+    "            outcome_weights = self.sample_outcome_weights()\n",
+    "            propensity_weights = self.sample_propensity_weights()\n",
+    "            tau = self.sample_treatment_weight()\n",
+    "            x_loc, x_scale = self.sample_covariate_loc_scale()\n",
+    "\n",
+    "        with pyro.plate(\"__train__\", size=self.X.shape[0], dim=-1):\n",
+    "            X = pyro.sample(\"X\", dist.Normal(x_loc, x_scale).to_event(1), obs=self.X)\n",
+    "            A = pyro.sample(\n",
+    "                \"A\",\n",
+    "                dist.Bernoulli(\n",
+    "                    logits=torch.einsum(\"ni,i->n\", self.X, propensity_weights)\n",
+    "                ),\n",
+    "                obs=self.A,\n",
+    "            )\n",
+    "            pyro.sample(\n",
+    "                \"Y\",\n",
+    "                self.link_fn(\n",
+    "                    torch.einsum(\"ni,i->n\", X, outcome_weights)\n",
+    "                    + A * tau\n",
+    "                    + intercept\n",
+    "                ),\n",
+    "                obs=self.Y,\n",
+    "            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 6.0.2 (20221011.1828)\n",
+       " -->\n",
+       "<!-- Pages: 1 -->\n",
+       "<svg width=\"563pt\" height=\"304pt\"\n",
+       " viewBox=\"0.00 0.00 563.39 304.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 300)\">\n",
+       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-300 559.39,-300 559.39,4 -4,4\"/>\n",
+       "<g id=\"clust1\" class=\"cluster\">\n",
+       "<title>cluster___train__</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" points=\"93.6,-8 93.6,-155 235.6,-155 235.6,-8 93.6,-8\"/>\n",
+       "<text text-anchor=\"middle\" x=\"201.6\" y=\"-15.8\" font-family=\"Times,serif\" font-size=\"14.00\">__train__</text>\n",
+       "</g>\n",
+       "<!-- intercept -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>intercept</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"41.6\" cy=\"-129\" rx=\"41.69\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"41.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">intercept</text>\n",
+       "</g>\n",
+       "<!-- Y -->\n",
+       "<g id=\"node7\" class=\"node\">\n",
+       "<title>Y</title>\n",
+       "<ellipse fill=\"gray\" stroke=\"black\" cx=\"200.6\" cy=\"-57\" rx=\"27\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"200.6\" y=\"-53.3\" font-family=\"Times,serif\" font-size=\"14.00\">Y</text>\n",
+       "</g>\n",
+       "<!-- intercept&#45;&gt;Y -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>intercept&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M69.66,-115.65C97.53,-103.38 140.19,-84.59 169.18,-71.83\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"170.71,-74.98 178.45,-67.75 167.89,-68.58 170.71,-74.98\"/>\n",
+       "</g>\n",
+       "<!-- outcome_weights -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>outcome_weights</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"318.6\" cy=\"-129\" rx=\"73.39\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"318.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">outcome_weights</text>\n",
+       "</g>\n",
+       "<!-- outcome_weights&#45;&gt;Y -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>outcome_weights&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M291.82,-112.12C273.12,-101.02 248.19,-86.23 229.12,-74.92\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"230.67,-71.77 220.28,-69.68 227.1,-77.79 230.67,-71.77\"/>\n",
+       "</g>\n",
+       "<!-- propensity_weights -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>propensity_weights</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"128.6\" cy=\"-239.5\" rx=\"79.09\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"128.6\" y=\"-235.8\" font-family=\"Times,serif\" font-size=\"14.00\">propensity_weights</text>\n",
+       "</g>\n",
+       "<!-- A -->\n",
+       "<g id=\"node6\" class=\"node\">\n",
+       "<title>A</title>\n",
+       "<ellipse fill=\"gray\" stroke=\"black\" cx=\"128.6\" cy=\"-129\" rx=\"27\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"128.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">A</text>\n",
+       "</g>\n",
+       "<!-- propensity_weights&#45;&gt;A -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>propensity_weights&#45;&gt;A</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M128.6,-221.07C128.6,-203.8 128.6,-177.12 128.6,-157.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"132.1,-157.03 128.6,-147.03 125.1,-157.03 132.1,-157.03\"/>\n",
+       "</g>\n",
+       "<!-- treatment_weight -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>treatment_weight</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"482.6\" cy=\"-129\" rx=\"72.59\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"482.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">treatment_weight</text>\n",
+       "</g>\n",
+       "<!-- treatment_weight&#45;&gt;Y -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>treatment_weight&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M433.15,-115.73C376.52,-101.67 285.18,-79 235.5,-66.66\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"236.11,-63.21 225.56,-64.2 234.42,-70 236.11,-63.21\"/>\n",
+       "</g>\n",
+       "<!-- X -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>X</title>\n",
+       "<ellipse fill=\"gray\" stroke=\"black\" cx=\"200.6\" cy=\"-129\" rx=\"27\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"200.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">X</text>\n",
+       "</g>\n",
+       "<!-- X&#45;&gt;Y -->\n",
+       "<g id=\"edge6\" class=\"edge\">\n",
+       "<title>X&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M200.6,-110.7C200.6,-102.98 200.6,-93.71 200.6,-85.11\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"204.1,-85.1 200.6,-75.1 197.1,-85.1 204.1,-85.1\"/>\n",
+       "</g>\n",
+       "<!-- A&#45;&gt;Y -->\n",
+       "<g id=\"edge5\" class=\"edge\">\n",
+       "<title>A&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M143.17,-113.83C153.35,-103.94 167.12,-90.55 178.63,-79.36\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"181.07,-81.87 185.8,-72.38 176.19,-76.85 181.07,-81.87\"/>\n",
+       "</g>\n",
+       "<!-- distribution_description_node -->\n",
+       "<g id=\"node8\" class=\"node\">\n",
+       "<title>distribution_description_node</title>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-280.8\" font-family=\"Times,serif\" font-size=\"14.00\">intercept ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-265.8\" font-family=\"Times,serif\" font-size=\"14.00\">outcome_weights ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-250.8\" font-family=\"Times,serif\" font-size=\"14.00\">propensity_weights ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-235.8\" font-family=\"Times,serif\" font-size=\"14.00\">treatment_weight ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-220.8\" font-family=\"Times,serif\" font-size=\"14.00\">X ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-205.8\" font-family=\"Times,serif\" font-size=\"14.00\">A ~ Bernoulli</text>\n",
+       "<text text-anchor=\"start\" x=\"234.1\" y=\"-190.8\" font-family=\"Times,serif\" font-size=\"14.00\">Y ~ Normal</text>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x10a39f090>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Visualize the model\n",
+    "pyro.render_model(\n",
+    "    ConditionedCausalGLM(torch.zeros(1, 1), torch.zeros(1), torch.zeros(1)),\n",
+    "    render_params=True, \n",
+    "    render_distributions=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generating data\n",
+    "\n",
+    "For evaluation, we generate `N_datasets` datasets, each with `N` samples. We compare vanilla estimates of the target functional with the double robust estimates of the target functional across the `N_sims` datasets. We use a similar data generating process as in Kennedy (2022)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GroundTruthModel(CausalGLM):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        p: int,\n",
+    "        alpha: int,\n",
+    "        beta: int,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        treatment_weight: float = 0.0,\n",
+    "    ):\n",
+    "        super().__init__(p, link_fn)\n",
+    "        self.alpha = alpha  # sparsity of propensity weights\n",
+    "        self.beta = beta  # sparsity of outcome weights\n",
+    "        self.treatment_weight = treatment_weight\n",
+    "\n",
+    "    def sample_outcome_weights(self):\n",
+    "        outcome_weights = 1 / math.sqrt(self.beta) * torch.ones(self.p)\n",
+    "        outcome_weights[self.beta :] = 0.0\n",
+    "        return outcome_weights\n",
+    "\n",
+    "    def sample_propensity_weights(self):\n",
+    "        propensity_weights = 1 / math.sqrt(self.alpha) * torch.ones(self.p)\n",
+    "        propensity_weights[self.alpha :] = 0.0\n",
+    "        return propensity_weights\n",
+    "\n",
+    "    def sample_treatment_weight(self):\n",
+    "        return torch.tensor(self.treatment_weight)\n",
+    "\n",
+    "    def sample_intercept(self):\n",
+    "        return torch.tensor(0.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Data configuration\n",
+    "p = 200\n",
+    "alpha = 50\n",
+    "beta = 50\n",
+    "N_train = 500\n",
+    "N_test = 500\n",
+    "\n",
+    "true_model = GroundTruthModel(p, alpha, beta)\n",
+    "\n",
+    "def generate_data(N_train, N_test):\n",
+    "    # Generate data\n",
+    "    D_train = Predictive(\n",
+    "        true_model, num_samples=N_train, return_sites=[\"X\", \"A\", \"Y\"]\n",
+    "    )()\n",
+    "    D_test = Predictive(\n",
+    "        true_model, num_samples=N_test, return_sites=[\"X\", \"A\", \"Y\"]\n",
+    "    )()\n",
+    "    return D_train, D_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Real Data\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "data = pd.read_csv(\"https://raw.githubusercontent.com/AMLab-Amsterdam/CEVAE/master/datasets/IHDP/csv/ihdp_npci_1.csv\", header = None)\n",
+    "col =  [\"treatment\", \"y_factual\", \"y_cfactual\", \"mu0\", \"mu1\" ,]\n",
+    "for i in range(1,26):\n",
+    "    col.append(\"x\"+str(i))\n",
+    "data.columns = col\n",
+    "data = data.astype({\"treatment\":'bool'}, copy=False)\n",
+    "\n",
+    "X_IHDP = torch.tensor(data.iloc[:,5:11].values, dtype=torch.float32)\n",
+    "A_IHDP = torch.tensor(data.treatment.values, dtype=torch.float32)\n",
+    "Y_IHDP = torch.tensor(data.y_factual.values, dtype=torch.float32)\n",
+    "\n",
+    "# Taken from DoWhy tutorial\n",
+    "ground_truth = 4.021121012430829\n",
+    "\n",
+    "# Split data\n",
+    "N_data_IHDP = data.shape[0]\n",
+    "p = X_IHDP.shape[1]\n",
+    "\n",
+    "def generate_IHDP_data():\n",
+    "    id_perm = torch.randperm(N_data_IHDP)\n",
+    "    train_idx = id_perm[: N_data_IHDP // 2]\n",
+    "    test_idx = id_perm[N_data_IHDP // 2 :]\n",
+    "\n",
+    "    D_train_IHDP = {\n",
+    "        \"X\": X_IHDP[train_idx],\n",
+    "        \"A\": A_IHDP[train_idx],\n",
+    "        \"Y\": Y_IHDP[train_idx],\n",
+    "    }\n",
+    "\n",
+    "    D_test_IHDP = {\n",
+    "        \"X\": X_IHDP[test_idx],\n",
+    "        \"A\": A_IHDP[test_idx],\n",
+    "        \"Y\": Y_IHDP[test_idx],\n",
+    "    }\n",
+    "\n",
+    "    return D_train_IHDP, D_test_IHDP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fit parameters via maximum likelihood"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def MLE(D_train, D_test):\n",
+    "    # Fit model using maximum likelihood\n",
+    "    conditioned_model = ConditionedCausalGLM(\n",
+    "        X=D_train[\"X\"], A=D_train[\"A\"], Y=D_train[\"Y\"]\n",
+    "    )\n",
+    "    \n",
+    "    guide_train = pyro.infer.autoguide.AutoDelta(conditioned_model)\n",
+    "    elbo = pyro.infer.Trace_ELBO()(conditioned_model, guide_train)\n",
+    "\n",
+    "    # initialize parameters\n",
+    "    elbo()\n",
+    "    adam = torch.optim.Adam(elbo.parameters(), lr=0.03)\n",
+    "\n",
+    "    # Do gradient steps\n",
+    "    for _ in range(2000):\n",
+    "        adam.zero_grad()\n",
+    "        with pyro.poutine.block(hide_fn=lambda msg: msg[\"type\"] == \"sample\"):\n",
+    "            loss = elbo()\n",
+    "            loss.backward()\n",
+    "        adam.step()\n",
+    "\n",
+    "    theta_hat = {\n",
+    "        k: v.clone().detach().requires_grad_(True) for k, v in guide_train().items()\n",
+    "    }\n",
+    "    return theta_hat"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Causal Query: Average treatment effect (ATE)\n",
+    "\n",
+    "The average treatment effect summarizes, on average, how much the treatment changes the response, $ATE = \\mathbb{E}[Y|do(A=1)] - \\mathbb{E}[Y|do(A=0)]$. The `do` notation indicates that the expectations are taken according to *intervened* versions of the model, with $A$ set to a particular value. Note from our [tutorial](tutorial_i.ipynb) that this is different from conditioning on $A$ in the original `causal_model`, which assumes $X$ and $T$ are dependent.\n",
+    "\n",
+    "\n",
+    "To implement this query in ChiRho, we define the `ATEFunctional` class which take in a `model` and `guide` and returns the average treatment effect by simulating from the posterior predictive distribution of the model and guide."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the target functional"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ATEFunctional(torch.nn.Module):\n",
+    "    def __init__(self, model: Callable, *, num_monte_carlo: int = 100):\n",
+    "        super().__init__()\n",
+    "        self.model = model\n",
+    "        self.num_monte_carlo = num_monte_carlo\n",
+    "    \n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        with MultiWorldCounterfactual():\n",
+    "            with pyro.plate(\"monte_carlo_functional\", size=self.num_monte_carlo, dim=-2):\n",
+    "                with do(actions=dict(A=(torch.tensor(0.0), torch.tensor(1.0)))):\n",
+    "                    Ys = self.model(*args, **kwargs)\n",
+    "                Y0 = gather(Ys, IndexSet(A={1}), event_dim=0)\n",
+    "                Y1 = gather(Ys, IndexSet(A={2}), event_dim=0)\n",
+    "        ate = (Y1 - Y0).mean(dim=-2, keepdim=True).mean(dim=-1, keepdim=True).squeeze()\n",
+    "        return pyro.deterministic(\"ATE\", ate)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Closed form doubly robust correction\n",
+    "\n",
+    "For the average treatment effect functional, there exists a closed-form analytical formula for the doubly robust correction. This formula is derived in Kennedy (2022) and is implemented below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Any\n",
+    "from chirho.robust.ops import Functional, Point, P, S, T\n",
+    "\n",
+    "def ate_causal_glm_analytic_influence(\n",
+    "    functional: Functional[P, S], \n",
+    "    point: Point[T], \n",
+    "    pointwise_influence: bool = True,\n",
+    "    **kwargs\n",
+    ") -> Functional[P, S]:\n",
+    "    def _ate_influence_functional(model: Callable[P, Any]) -> Callable[P, S]:\n",
+    "        assert isinstance(model.model, CausalGLM)\n",
+    "        theta = dict(model.guide.named_parameters())\n",
+    "        def correction(*args, **kwargs):\n",
+    "            X = point[\"X\"]\n",
+    "            A = point[\"A\"]\n",
+    "            Y = point[\"Y\"]\n",
+    "            \n",
+    "            pi_X = torch.sigmoid(torch.einsum(\"...i,...i->...\", X, theta[\"propensity_weights_param\"]))\n",
+    "            mu_X = (\n",
+    "                torch.einsum(\"...i,...i->...\", X, theta[\"outcome_weights_param\"])\n",
+    "                + A * theta[\"treatment_weight_param\"]\n",
+    "                + theta[\"intercept_param\"]\n",
+    "            )\n",
+    "            analytic_eif_at_pts = (A / pi_X - (1 - A) / (1 - pi_X)) * (Y - mu_X)\n",
+    "            if pointwise_influence:\n",
+    "                return analytic_eif_at_pts\n",
+    "            else:\n",
+    "                return analytic_eif_at_pts.mean()\n",
+    "        return correction\n",
+    "    \n",
+    "    return _ate_influence_functional"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Computing automated doubly robust estimators via Monte Carlo\n",
+    "\n",
+    "While the doubly robust correction term is known in closed-form for the average treatment effect functional, our `one_step_correction` and `tmle` function in `ChiRho` works for a wide class of other functionals. We focus on the average treatment effect functional here so that we have a ground truth to compare `one_step_correction` and `tmle` against. We also compare against DoubleML estimator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Helper class to create a trivial guide that returns the maximum likelihood estimate\n",
+    "class MLEGuide(torch.nn.Module):\n",
+    "    def __init__(self, mle_est: ParamDict):\n",
+    "        super().__init__()\n",
+    "        self.names = list(mle_est.keys())\n",
+    "        for name, value in mle_est.items():\n",
+    "            setattr(self, name + \"_param\", torch.nn.Parameter(value))\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        for name in self.names:\n",
+    "            value = getattr(self, name + \"_param\")\n",
+    "            pyro.sample(\n",
+    "                name, pyro.distributions.Delta(value, event_dim=len(value.shape))\n",
+    "            )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import os\n",
+    "\n",
+    "# Compute doubly robust ATE estimates using both the automated and closed form expressions\n",
+    "N_datasets = 90\n",
+    "\n",
+    "\n",
+    "# Estimators to compare\n",
+    "estimators = {\"tmle\": tmle, \"one_step\": one_step_corrected_estimator, \"double_ml\": None} # We'll do DoubleML in the loop\n",
+    "# estimators = {\"one_step\": one_step_corrected_estimator, \"double_ml\": None} # We'll do DoubleML in the loop\n",
+    "estimator_kwargs = {\n",
+    "    \"tmle\": {\n",
+    "        \"learning_rate\": 5e-5,\n",
+    "        \"n_grad_steps\": 500,\n",
+    "        \"n_tmle_steps\": 1,\n",
+    "        \"num_nmc_samples\": 1, # Since we're using point estimate\n",
+    "        \"num_grad_samples\": N_test\n",
+    "    }, \n",
+    "    \"one_step\": {}\n",
+    "}\n",
+    "\n",
+    "# Influence functions\n",
+    "influences = {\"analytic_eif\": ate_causal_glm_analytic_influence, \"monte_carlo_eif\": influence_fn}\n",
+    "\n",
+    "# Cache the results\n",
+    "# RESULTS_PATH = \"../results/ate_causal_glm.json\"\n",
+    "RESULTS_PATH = \"../results/ate_causal_glm_ihdp.json\"\n",
+    "\n",
+    "if os.path.exists(RESULTS_PATH):\n",
+    "    with open(RESULTS_PATH, \"r\") as f:\n",
+    "        estimates = json.load(f)\n",
+    "    i_start = len(estimates[\"plug-in-mle-from-model\"]) \n",
+    "else:\n",
+    "    estimates = {f\"{influence}-{estimator}\": [] for influence in influences.keys() for estimator in estimators.keys()}\n",
+    "    estimates[\"plug-in-mle-from-model\"] = []\n",
+    "    estimates[\"plug-in-mle-from-test\"] = []\n",
+    "    i_start = 0\n",
+    "\n",
+    "# ATE functional of interest\n",
+    "functional = functools.partial(ATEFunctional, num_monte_carlo=10000)\n",
+    "\n",
+    "for i in range(i_start, N_datasets):\n",
+    "    pyro.set_rng_seed(i) # for reproducibility\n",
+    "    print(\"Dataset\", i)\n",
+    "    # D_train, D_test = generate_data(N_train, N_test)\n",
+    "    D_train, D_test = generate_IHDP_data()\n",
+    "    theta_hat = MLE(D_train, D_test)\n",
+    "\n",
+    "    theta_hat = {\n",
+    "        k: v.clone().detach().requires_grad_(True) for k, v in theta_hat.items()\n",
+    "    }\n",
+    "    mle_guide = MLEGuide(theta_hat)\n",
+    "    model = PredictiveModel(CausalGLM(p), mle_guide)\n",
+    "    \n",
+    "    print(\"plug-in-mle-from-model\", i)\n",
+    "    estimates[\"plug-in-mle-from-model\"].append(functional(model)().detach().item())\n",
+    "\n",
+    "    mu_X = (\n",
+    "        torch.einsum(\"...i,...i->...\", D_test[\"X\"], theta_hat[\"outcome_weights\"])\n",
+    "        + D_test[\"A\"] * theta_hat[\"treatment_weight\"]\n",
+    "        + theta_hat[\"intercept\"]\n",
+    "    )\n",
+    "    \n",
+    "    mu_X_treat = mu_X[D_test[\"A\"] == 1]\n",
+    "    mu_X_control = mu_X[D_test[\"A\"] == 0]\n",
+    "    \n",
+    "    # Used for DoubleML later on\n",
+    "    estimates[\"plug-in-mle-from-test\"].append((mu_X_treat.mean() - mu_X_control.mean()).detach().item())\n",
+    "\n",
+    "    for estimator_str, estimator in estimators.items():\n",
+    "        if estimator_str != 'double_ml':\n",
+    "            for influence_str, influence in influences.items():\n",
+    "                print(estimator_str, influence_str, i)\n",
+    "                estimate = estimator(\n",
+    "                    functional, \n",
+    "                    D_test,\n",
+    "                    num_samples_outer=max(10000, 1000 * p), \n",
+    "                    num_samples_inner=1,\n",
+    "                    influence_estimator=influence,\n",
+    "                    **estimator_kwargs[estimator_str]\n",
+    "                )(PredictiveModel(CausalGLM(p), mle_guide))()\n",
+    "\n",
+    "                estimates[f\"{influence_str}-{estimator_str}\"].append(estimate.detach().item())\n",
+    "                \n",
+    "    # Compute DoubleML estimate (see Proposition in our paper for this trick to reduce one step to DoubleML)\n",
+    "    if 'one_step' in estimators.keys():\n",
+    "        for influence_str, influence in influences.items():\n",
+    "            eif_correction = estimates[f\"{influence_str}-one_step\"][i] - estimates[\"plug-in-mle-from-model\"][i]\n",
+    "            double_ml = estimates[\"plug-in-mle-from-test\"][i] + eif_correction\n",
+    "            estimates[f\"{influence_str}-double_ml\"].append(double_ml)\n",
+    "\n",
+    "    with open(RESULTS_PATH, \"w\") as f:\n",
+    "        json.dump(estimates, f, indent=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>analytic_eif-tmle</th>\n",
+       "      <th>analytic_eif-one_step</th>\n",
+       "      <th>analytic_eif-double_ml</th>\n",
+       "      <th>monte_carlo_eif-tmle</th>\n",
+       "      <th>monte_carlo_eif-one_step</th>\n",
+       "      <th>monte_carlo_eif-double_ml</th>\n",
+       "      <th>plug-in-mle-from-model</th>\n",
+       "      <th>plug-in-mle-from-test</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "      <td>92.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>3.81</td>\n",
+       "      <td>3.81</td>\n",
+       "      <td>3.97</td>\n",
+       "      <td>3.81</td>\n",
+       "      <td>3.83</td>\n",
+       "      <td>3.98</td>\n",
+       "      <td>3.81</td>\n",
+       "      <td>3.96</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.12</td>\n",
+       "      <td>0.16</td>\n",
+       "      <td>0.10</td>\n",
+       "      <td>0.11</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.11</td>\n",
+       "      <td>0.15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>3.53</td>\n",
+       "      <td>3.59</td>\n",
+       "      <td>3.64</td>\n",
+       "      <td>3.52</td>\n",
+       "      <td>3.63</td>\n",
+       "      <td>3.71</td>\n",
+       "      <td>3.50</td>\n",
+       "      <td>3.64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>3.76</td>\n",
+       "      <td>3.72</td>\n",
+       "      <td>3.86</td>\n",
+       "      <td>3.75</td>\n",
+       "      <td>3.76</td>\n",
+       "      <td>3.89</td>\n",
+       "      <td>3.75</td>\n",
+       "      <td>3.85</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>3.81</td>\n",
+       "      <td>3.80</td>\n",
+       "      <td>3.96</td>\n",
+       "      <td>3.81</td>\n",
+       "      <td>3.82</td>\n",
+       "      <td>3.97</td>\n",
+       "      <td>3.79</td>\n",
+       "      <td>3.96</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>3.85</td>\n",
+       "      <td>3.86</td>\n",
+       "      <td>4.07</td>\n",
+       "      <td>3.87</td>\n",
+       "      <td>3.87</td>\n",
+       "      <td>4.08</td>\n",
+       "      <td>3.87</td>\n",
+       "      <td>4.06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>4.08</td>\n",
+       "      <td>4.16</td>\n",
+       "      <td>4.44</td>\n",
+       "      <td>4.07</td>\n",
+       "      <td>4.14</td>\n",
+       "      <td>4.42</td>\n",
+       "      <td>4.09</td>\n",
+       "      <td>4.30</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       analytic_eif-tmle  analytic_eif-one_step  analytic_eif-double_ml  \\\n",
+       "count              92.00                  92.00                   92.00   \n",
+       "mean                3.81                   3.81                    3.97   \n",
+       "std                 0.09                   0.12                    0.16   \n",
+       "min                 3.53                   3.59                    3.64   \n",
+       "25%                 3.76                   3.72                    3.86   \n",
+       "50%                 3.81                   3.80                    3.96   \n",
+       "75%                 3.85                   3.86                    4.07   \n",
+       "max                 4.08                   4.16                    4.44   \n",
+       "\n",
+       "       monte_carlo_eif-tmle  monte_carlo_eif-one_step  \\\n",
+       "count                 92.00                     92.00   \n",
+       "mean                   3.81                      3.83   \n",
+       "std                    0.10                      0.11   \n",
+       "min                    3.52                      3.63   \n",
+       "25%                    3.75                      3.76   \n",
+       "50%                    3.81                      3.82   \n",
+       "75%                    3.87                      3.87   \n",
+       "max                    4.07                      4.14   \n",
+       "\n",
+       "       monte_carlo_eif-double_ml  plug-in-mle-from-model  \\\n",
+       "count                      92.00                   92.00   \n",
+       "mean                        3.98                    3.81   \n",
+       "std                         0.15                    0.11   \n",
+       "min                         3.71                    3.50   \n",
+       "25%                         3.89                    3.75   \n",
+       "50%                         3.97                    3.79   \n",
+       "75%                         4.08                    3.87   \n",
+       "max                         4.42                    4.09   \n",
+       "\n",
+       "       plug-in-mle-from-test  \n",
+       "count                  92.00  \n",
+       "mean                    3.96  \n",
+       "std                     0.15  \n",
+       "min                     3.64  \n",
+       "25%                     3.85  \n",
+       "50%                     3.96  \n",
+       "75%                     4.06  \n",
+       "max                     4.30  "
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The true treatment effect is 0, so a mean estimate closer to zero is better\n",
+    "results = pd.DataFrame(estimates)\n",
+    "results.describe().round(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# use tex\n",
+    "plt.rcParams['text.usetex'] = False\n",
+    "\n",
+    "# Visualize the results\n",
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "\n",
+    "# # TMLE\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['analytic_eif-tmle'], \n",
+    "#     ax=ax,\n",
+    "#     color='blue',\n",
+    "#     linestyle='--'\n",
+    "# )\n",
+    "\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['monte_carlo_eif-tmle'], \n",
+    "#     label=\"TMLE\",\n",
+    "#     ax=ax,\n",
+    "#     color='blue'\n",
+    "# )\n",
+    "\n",
+    "# # One-step\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['analytic_eif-one_step'], \n",
+    "#     ax=ax,\n",
+    "#     color='red',\n",
+    "#     linestyle='--'\n",
+    "# )\n",
+    "\n",
+    "# sns.kdeplot(\n",
+    "#     estimates['monte_carlo_eif-one_step'], \n",
+    "#     label=\"One-Step\",\n",
+    "#     ax=ax,\n",
+    "#     color='red'\n",
+    "# )\n",
+    "\n",
+    "# DoubleML\n",
+    "sns.kdeplot(\n",
+    "    estimates['analytic_eif-double_ml'], \n",
+    "    ax=ax,\n",
+    "    color='green',\n",
+    "    linestyle='--'\n",
+    ")\n",
+    "\n",
+    "sns.kdeplot(\n",
+    "    estimates['monte_carlo_eif-double_ml'], \n",
+    "    label=\"DoubleML\",\n",
+    "    ax=ax,\n",
+    "    color='green'\n",
+    ")\n",
+    "\n",
+    "# Plug-in MLE\n",
+    "sns.kdeplot(\n",
+    "    estimates['plug-in-mle-from-model'], \n",
+    "    label=\"Plug-in\",\n",
+    "    ax=ax,\n",
+    "    color='brown'\n",
+    ")\n",
+    "\n",
+    "ax.axvline(ground_truth, color=\"black\", label=\"Ground Truth\", linestyle=\"solid\")\n",
+    "ax.set_yticks([])\n",
+    "sns.despine()\n",
+    "ax.set_xlabel(\"ATE Estimate\", fontsize=18)\n",
+    "ax.set_ylabel(\"Density\", fontsize=18)\n",
+    "\n",
+    "ax.legend(loc=\"upper right\", fontsize=11)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "plt.savefig('figures/causal_glm_performance_vs_estimator_just_doubleml.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# fig, ax = plt.subplots(figsize=(6, 3))\n",
+    "\n",
+    "# Double ML\n",
+    "plt.scatter(\n",
+    "    estimates['monte_carlo_eif-double_ml'],\n",
+    "    estimates['analytic_eif-double_ml'],\n",
+    "    color='green',\n",
+    ")\n",
+    "\n",
+    "# Plot y=x line for min and max values\n",
+    "min_val = min(\n",
+    "    min(estimates['monte_carlo_eif-double_ml']),\n",
+    "    min(estimates['analytic_eif-double_ml'])\n",
+    ")\n",
+    "max_val = max(\n",
+    "    max(estimates['monte_carlo_eif-double_ml']),\n",
+    "    max(estimates['analytic_eif-double_ml'])\n",
+    ")\n",
+    "plt.plot([min_val, max_val], [min_val, max_val], color='black', linestyle='--')\n",
+    "plt.xlabel(\"MC-EIF\", fontsize=40)\n",
+    "plt.ylabel(\"EIF\", fontsize=40)\n",
+    "sns.despine()\n",
+    "plt.xticks([round(1.1*max_val,1)], fontsize=30)\n",
+    "plt.yticks([round(0.9*min_val, 1), round(1.1*max_val,1)], fontsize=30)\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('./figures/double_convergence_causal_glm.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# fig, ax = plt.subplots(figsize=(6, 3))\n",
+    "\n",
+    "# TMLE\n",
+    "plt.scatter(\n",
+    "    estimates['monte_carlo_eif-tmle'],\n",
+    "    estimates['analytic_eif-tmle'],\n",
+    "    color='blue',\n",
+    ")\n",
+    "\n",
+    "# Plot y=x line for min and max values\n",
+    "min_val = min(\n",
+    "    min(estimates['monte_carlo_eif-tmle']),\n",
+    "    min(estimates['analytic_eif-tmle'])\n",
+    ")\n",
+    "max_val = max(\n",
+    "    max(estimates['monte_carlo_eif-tmle']),\n",
+    "    max(estimates['analytic_eif-tmle'])\n",
+    ")\n",
+    "plt.plot([min_val, max_val], [min_val, max_val], color='black', linestyle='--')\n",
+    "plt.xlabel(\"MC-EIF\", fontsize=40)\n",
+    "plt.ylabel(\"EIF\", fontsize=40)\n",
+    "sns.despine()\n",
+    "plt.xticks([round(1.1*max_val,1)], fontsize=30)\n",
+    "plt.yticks([round(0.9*min_val, 1), round(1.1*max_val,1)], fontsize=30)\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('./figures/tmle_convergence_causal_glm.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# fig, ax = plt.subplots(figsize=(6, 3))\n",
+    "\n",
+    "# One-step\n",
+    "plt.scatter(\n",
+    "    estimates['monte_carlo_eif-one_step'],\n",
+    "    estimates['analytic_eif-one_step'],\n",
+    "    color='red',\n",
+    ")\n",
+    "\n",
+    "# Plot y=x line for min and max values\n",
+    "min_val = min(\n",
+    "    min(estimates['monte_carlo_eif-one_step']),\n",
+    "    min(estimates['analytic_eif-one_step'])\n",
+    ")\n",
+    "max_val = max(\n",
+    "    max(estimates['monte_carlo_eif-one_step']),\n",
+    "    max(estimates['analytic_eif-one_step'])\n",
+    ")\n",
+    "plt.plot([min_val, max_val], [min_val, max_val], color='black', linestyle='--')\n",
+    "plt.xlabel(\"MC-EIF\", fontsize=40)\n",
+    "plt.ylabel(\"EIF\", fontsize=40)\n",
+    "sns.despine()\n",
+    "plt.xticks([round(1.1*max_val,1)], fontsize=30)\n",
+    "plt.yticks([round(0.9*min_val, 1), round(1.1*max_val,1)], fontsize=30)\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('./figures/one_step_convergence_causal_glm.png')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "Kennedy, Edward. \"Towards optimal doubly robust estimation of heterogeneous causal effects\", 2022. https://arxiv.org/abs/2004.14497."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "chirho-robust",
+   "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.11.10"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/examples/robust_paper/results/_ate_causal_glm_tmle.json b/docs/examples/robust_paper/results/_ate_causal_glm_tmle.json
new file mode 100644
index 00000000..39876026
--- /dev/null
+++ b/docs/examples/robust_paper/results/_ate_causal_glm_tmle.json
@@ -0,0 +1,614 @@
+{
+    "analytic_eif-one_step": [
+        3.811537504196167,
+        4.137718200683594,
+        3.9080848693847656,
+        3.996136426925659,
+        4.015166282653809,
+        3.8464725017547607,
+        3.8703866004943848,
+        3.7797505855560303,
+        3.925191640853882,
+        3.9323484897613525,
+        3.8160758018493652,
+        3.8378331661224365,
+        3.9371795654296875,
+        3.6806788444519043,
+        3.9664194583892822,
+        3.871370315551758,
+        3.7771315574645996,
+        3.738832712173462,
+        3.842334747314453,
+        3.99088716506958,
+        3.936116933822632,
+        3.7041239738464355,
+        3.85697603225708,
+        3.9458742141723633,
+        3.9586732387542725,
+        3.829660654067993,
+        4.046951770782471,
+        3.976670503616333,
+        3.9545791149139404,
+        3.9438703060150146,
+        3.8190581798553467,
+        4.001430988311768,
+        3.880505084991455,
+        3.8688385486602783,
+        3.6270105838775635,
+        3.8348121643066406,
+        3.9116954803466797,
+        4.1246867179870605,
+        3.67423677444458,
+        3.8382620811462402,
+        3.844770669937134,
+        3.8843958377838135,
+        3.867672920227051,
+        3.840637683868408,
+        4.0203142166137695,
+        3.8423256874084473,
+        3.8996334075927734,
+        3.9039106369018555,
+        3.952975034713745,
+        3.854522228240967,
+        3.9894351959228516,
+        3.8697874546051025,
+        3.8418798446655273,
+        3.9072277545928955,
+        3.883012056350708,
+        3.8110501766204834,
+        4.116669178009033,
+        4.078433036804199,
+        3.9935598373413086,
+        3.8877406120300293,
+        4.028015613555908,
+        4.002680778503418,
+        3.812573194503784,
+        3.88881254196167,
+        3.9829585552215576,
+        3.55172061920166,
+        3.9023597240448,
+        3.640474796295166,
+        3.792064666748047,
+        4.10162878036499,
+        4.004901885986328,
+        3.7332096099853516,
+        3.822956085205078,
+        3.915196418762207,
+        3.7444167137145996,
+        3.863767623901367,
+        3.9317142963409424,
+        3.8431315422058105,
+        3.873445987701416,
+        3.8526813983917236,
+        3.910060405731201,
+        3.886991262435913,
+        3.9494197368621826,
+        3.972322940826416,
+        3.896486759185791,
+        3.786491870880127,
+        3.983001708984375,
+        4.142300605773926,
+        3.9770729541778564,
+        3.8937225341796875,
+        3.9332878589630127,
+        3.8069112300872803,
+        3.8995518684387207,
+        3.879728078842163,
+        3.8723621368408203,
+        4.013252258300781,
+        3.8342928886413574,
+        3.765767812728882,
+        3.8580093383789062,
+        3.9173758029937744
+    ],
+    "analytic_eif-double_ml": [
+        3.978489398956299,
+        4.273711681365967,
+        3.945242166519165,
+        4.215897560119629,
+        4.1247899532318115,
+        4.200973272323608,
+        3.984631299972534,
+        3.975872755050659,
+        4.109742879867554,
+        4.111649036407471,
+        3.965789318084717,
+        4.022806167602539,
+        4.112804174423218,
+        3.8000097274780273,
+        4.04800820350647,
+        4.09093451499939,
+        3.9628517627716064,
+        3.9008960723876953,
+        3.9747138023376465,
+        4.112841606140137,
+        3.902204990386963,
+        3.8832387924194336,
+        4.0018391609191895,
+        3.8117172718048096,
+        4.01831316947937,
+        3.92330265045166,
+        4.125944137573242,
+        4.01739764213562,
+        3.909925699234009,
+        4.023115396499634,
+        3.9718217849731445,
+        4.139090538024902,
+        4.030466079711914,
+        3.933239459991455,
+        3.831829309463501,
+        4.1501147747039795,
+        4.033329725265503,
+        4.154767990112305,
+        3.9462532997131348,
+        3.967388391494751,
+        4.103285551071167,
+        3.9965388774871826,
+        3.839362859725952,
+        4.0559186935424805,
+        4.164015531539917,
+        3.9645676612854004,
+        3.8882102966308594,
+        4.068742275238037,
+        4.073702096939087,
+        3.9949193000793457,
+        4.16347861289978,
+        4.027357339859009,
+        3.983051300048828,
+        3.863316297531128,
+        4.163138151168823,
+        3.927809238433838,
+        4.096214532852173,
+        4.081921815872192,
+        4.278963327407837,
+        4.01162314414978,
+        4.231368064880371,
+        4.066718339920044,
+        3.911529541015625,
+        3.919628858566284,
+        4.0176801681518555,
+        3.6871604919433594,
+        4.018279790878296,
+        3.7944469451904297,
+        3.9608778953552246,
+        4.2301599979400635,
+        3.993351697921753,
+        3.9016988277435303,
+        3.9409358501434326,
+        4.085007429122925,
+        3.9873580932617188,
+        3.925424814224243,
+        3.957277297973633,
+        4.097668647766113,
+        3.9452850818634033,
+        3.9332616329193115,
+        4.092364311218262,
+        4.085864543914795,
+        4.062970876693726,
+        4.099432945251465,
+        3.9875595569610596,
+        3.8747456073760986,
+        4.0005879402160645,
+        4.159684896469116,
+        4.0105812549591064,
+        4.003722429275513,
+        4.094360113143921,
+        3.8591268062591553,
+        4.016741037368774,
+        4.140474319458008,
+        4.074481248855591,
+        4.119319438934326,
+        3.9506094455718994,
+        3.848675012588501,
+        4.026105880737305,
+        3.945129156112671
+    ],
+    "monte_carlo_eif-one_step": [
+        3.886310577392578,
+        3.986647605895996,
+        3.8481321334838867,
+        3.9144153594970703,
+        3.8723249435424805,
+        3.8127896785736084,
+        3.872513771057129,
+        3.849851131439209,
+        3.8553168773651123,
+        3.904918909072876,
+        3.868342399597168,
+        3.86655330657959,
+        3.868569850921631,
+        3.7888805866241455,
+        3.889655590057373,
+        3.8841545581817627,
+        3.8395981788635254,
+        3.824368715286255,
+        3.846395969390869,
+        3.929871082305908,
+        3.8691813945770264,
+        3.78287935256958,
+        3.853332042694092,
+        3.851668357849121,
+        3.8774375915527344,
+        3.879287004470825,
+        3.9004580974578857,
+        3.9386515617370605,
+        3.881422281265259,
+        3.8720571994781494,
+        3.865736246109009,
+        3.887582540512085,
+        3.8671181201934814,
+        3.8569905757904053,
+        3.7561917304992676,
+        3.865675687789917,
+        3.8776657581329346,
+        3.927882194519043,
+        3.7859368324279785,
+        3.79994797706604,
+        3.8702893257141113,
+        3.882352590560913,
+        3.836264133453369,
+        3.892845869064331,
+        3.942333459854126,
+        3.838653326034546,
+        3.832059144973755,
+        3.909579277038574,
+        3.8872432708740234,
+        3.8600049018859863,
+        3.9237449169158936,
+        3.869767904281616,
+        3.8327977657318115,
+        3.8425047397613525,
+        3.8652536869049072,
+        3.829322576522827,
+        3.9115071296691895,
+        3.930755853652954,
+        3.9934678077697754,
+        3.898998498916626,
+        3.949323892593384,
+        3.914181709289551,
+        3.790423631668091,
+        3.8530025482177734,
+        3.9069368839263916,
+        3.7546629905700684,
+        3.8736417293548584,
+        3.759167194366455,
+        3.815664768218994,
+        3.986612558364868,
+        3.902860641479492,
+        3.8390989303588867,
+        3.815469980239868,
+        3.865018129348755,
+        3.8334691524505615,
+        3.857327938079834,
+        3.8774352073669434,
+        3.8610446453094482,
+        3.8633246421813965,
+        3.8143150806427,
+        3.869490146636963,
+        3.903139114379883,
+        3.9180212020874023,
+        3.9165332317352295,
+        3.854038715362549,
+        3.8217856884002686,
+        3.8451597690582275,
+        3.9427990913391113,
+        3.888766050338745,
+        3.9021971225738525,
+        3.8714537620544434,
+        3.8794827461242676,
+        3.8535990715026855,
+        3.8814127445220947,
+        3.8804593086242676,
+        3.8903703689575195,
+        3.8486297130584717,
+        3.82654070854187,
+        3.8604018688201904,
+        3.899303674697876
+    ],
+    "monte_carlo_eif-double_ml": [
+        4.05326247215271,
+        4.122641086578369,
+        3.885289430618286,
+        4.13417649269104,
+        3.9819486141204834,
+        4.167290449142456,
+        3.9867584705352783,
+        4.045973300933838,
+        4.039868116378784,
+        4.084219455718994,
+        4.0180559158325195,
+        4.051526308059692,
+        4.044194459915161,
+        3.9082114696502686,
+        3.9712443351745605,
+        4.1037187576293945,
+        4.025318384170532,
+        3.9864320755004883,
+        3.9787750244140625,
+        4.051825523376465,
+        3.8352694511413574,
+        3.961994171142578,
+        3.998195171356201,
+        3.7175114154815674,
+        3.937077522277832,
+        3.972929000854492,
+        3.9794504642486572,
+        3.9793787002563477,
+        3.836768865585327,
+        3.9513022899627686,
+        4.018499851226807,
+        4.02524209022522,
+        4.01707911491394,
+        3.921391487121582,
+        3.961010456085205,
+        4.180978298187256,
+        3.999300003051758,
+        3.957963466644287,
+        4.057953357696533,
+        3.929074287414551,
+        4.1288042068481445,
+        3.9944956302642822,
+        3.8079540729522705,
+        4.108126878738403,
+        4.086034774780273,
+        3.960895299911499,
+        3.820636034011841,
+        4.074410915374756,
+        4.007970333099365,
+        4.000401973724365,
+        4.097788333892822,
+        4.0273377895355225,
+        3.9739692211151123,
+        3.798593282699585,
+        4.1453797817230225,
+        3.9460816383361816,
+        3.891052484512329,
+        3.9342446327209473,
+        4.278871297836304,
+        4.022881031036377,
+        4.152676343917847,
+        3.9782192707061768,
+        3.8893799781799316,
+        3.8838188648223877,
+        3.9416584968566895,
+        3.8901028633117676,
+        3.9895617961883545,
+        3.9131393432617188,
+        3.984477996826172,
+        4.115143775939941,
+        3.891310453414917,
+        4.007588148117065,
+        3.9334497451782227,
+        4.034829139709473,
+        4.076410531997681,
+        3.91898512840271,
+        3.902998208999634,
+        4.115581750869751,
+        3.935163736343384,
+        3.894895315170288,
+        4.051794052124023,
+        4.102012395858765,
+        4.031572341918945,
+        4.043643236160278,
+        3.9451115131378174,
+        3.9100394248962402,
+        3.862746000289917,
+        3.9601833820343018,
+        3.922274351119995,
+        4.012197017669678,
+        4.032526016235352,
+        3.9316983222961426,
+        3.9707882404327393,
+        4.1421589851379395,
+        4.082578420639038,
+        3.9964375495910645,
+        3.9649462699890137,
+        3.9094479084014893,
+        4.028498411178589,
+        3.9270570278167725
+    ],
+    "plug-in-mle-from-model": [
+        3.853281259536743,
+        3.462830066680908,
+        3.7969393730163574,
+        3.7084543704986572,
+        3.6862874031066895,
+        3.845517158508301,
+        3.809166431427002,
+        3.883957862854004,
+        3.784637928009033,
+        3.825434446334839,
+        3.9305834770202637,
+        3.9361464977264404,
+        3.8050332069396973,
+        4.055565357208252,
+        3.8237879276275635,
+        3.8487918376922607,
+        3.971686601638794,
+        3.8512980937957764,
+        3.959775447845459,
+        3.757720708847046,
+        3.814213752746582,
+        4.024913311004639,
+        3.8687472343444824,
+        3.8433423042297363,
+        3.7881031036376953,
+        3.932218313217163,
+        3.752290964126587,
+        3.8353116512298584,
+        3.8782718181610107,
+        3.8184187412261963,
+        3.8876593112945557,
+        3.8097643852233887,
+        3.8414793014526367,
+        3.8463058471679688,
+        4.129661560058594,
+        3.907897710800171,
+        3.8415136337280273,
+        3.5930867195129395,
+        4.039006233215332,
+        3.981438398361206,
+        3.940135955810547,
+        3.783015251159668,
+        3.9398882389068604,
+        3.8438515663146973,
+        3.693995237350464,
+        3.896663188934326,
+        3.8311421871185303,
+        3.8683505058288574,
+        3.8611035346984863,
+        3.901801586151123,
+        3.781221389770508,
+        3.7833847999572754,
+        3.830843687057495,
+        3.8904082775115967,
+        3.821166515350342,
+        3.9290249347686768,
+        3.679781198501587,
+        3.6168174743652344,
+        3.72082257270813,
+        3.9061543941497803,
+        3.702427387237549,
+        3.7753067016601562,
+        3.919128179550171,
+        3.8068714141845703,
+        3.745384693145752,
+        4.092693328857422,
+        3.7852890491485596,
+        4.142066478729248,
+        4.015684604644775,
+        3.5732979774475098,
+        3.7762093544006348,
+        3.993074655532837,
+        3.9076988697052,
+        3.7488656044006348,
+        3.9558663368225098,
+        3.9195876121520996,
+        3.892676591873169,
+        3.839564800262451,
+        3.779057025909424,
+        3.8865957260131836,
+        3.771259069442749,
+        3.8071014881134033,
+        3.73764967918396,
+        3.7247836589813232,
+        3.8654887676239014,
+        3.99128794670105,
+        3.765838384628296,
+        3.6490554809570312,
+        3.816884756088257,
+        3.813601493835449,
+        3.7765276432037354,
+        4.01057243347168,
+        3.8193862438201904,
+        3.79966139793396,
+        3.7983086109161377,
+        3.7344155311584473,
+        3.9302961826324463,
+        3.9614148139953613,
+        4.007858753204346,
+        3.852307081222534
+    ],
+    "plug-in-mle-from-test": [
+        4.020233154296875,
+        3.5988235473632812,
+        3.834096670150757,
+        3.928215503692627,
+        3.7959110736846924,
+        4.200017929077148,
+        3.9234111309051514,
+        4.080080032348633,
+        3.969189167022705,
+        4.004734992980957,
+        4.080296993255615,
+        4.121119499206543,
+        3.9806578159332275,
+        4.174896240234375,
+        3.905376672744751,
+        4.068356037139893,
+        4.157406806945801,
+        4.01336145401001,
+        4.092154502868652,
+        3.8796751499176025,
+        3.780301809310913,
+        4.204028129577637,
+        4.013610363006592,
+        3.7091853618621826,
+        3.847743034362793,
+        4.02586030960083,
+        3.8312833309173584,
+        3.8760387897491455,
+        3.833618402481079,
+        3.8976638317108154,
+        4.0404229164123535,
+        3.9474239349365234,
+        3.9914402961730957,
+        3.9107067584991455,
+        4.334480285644531,
+        4.22320032119751,
+        3.9631478786468506,
+        3.6231679916381836,
+        4.311022758483887,
+        4.110564708709717,
+        4.19865083694458,
+        3.895158290863037,
+        3.9115781784057617,
+        4.0591325759887695,
+        3.8376965522766113,
+        4.018905162811279,
+        3.819719076156616,
+        4.033182144165039,
+        3.981830596923828,
+        4.042198657989502,
+        3.9552648067474365,
+        3.9409546852111816,
+        3.972015142440796,
+        3.846496820449829,
+        4.101292610168457,
+        4.045783996582031,
+        3.6593265533447266,
+        3.6203062534332275,
+        4.006226062774658,
+        4.030036926269531,
+        3.9057798385620117,
+        3.8393442630767822,
+        4.018084526062012,
+        3.8376877307891846,
+        3.78010630607605,
+        4.228133201599121,
+        3.9012091159820557,
+        4.296038627624512,
+        4.184497833251953,
+        3.701829195022583,
+        3.7646591663360596,
+        4.161563873291016,
+        4.025678634643555,
+        3.9186766147613525,
+        4.198807716369629,
+        3.9812448024749756,
+        3.9182395935058594,
+        4.094101905822754,
+        3.850896120071411,
+        3.9671759605407715,
+        3.9535629749298096,
+        4.005974769592285,
+        3.851200819015503,
+        3.851893663406372,
+        3.95656156539917,
+        4.0795416831970215,
+        3.7834246158599854,
+        3.6664397716522217,
+        3.850393056869507,
+        3.9236013889312744,
+        3.9375998973846436,
+        4.062788009643555,
+        3.936575412750244,
+        4.060407638549805,
+        4.000427722930908,
+        3.840482711791992,
+        4.046612739562988,
+        4.0443220138549805,
+        4.175955295562744,
+        3.8800604343414307
+    ]
+}
\ No newline at end of file
diff --git a/docs/examples/robust_paper/results/ate_causal_glm.json b/docs/examples/robust_paper/results/ate_causal_glm.json
new file mode 100644
index 00000000..992cff1b
--- /dev/null
+++ b/docs/examples/robust_paper/results/ate_causal_glm.json
@@ -0,0 +1,818 @@
+{
+    "analytic_eif-tmle": [
+        0.29480472207069397,
+        0.154845729470253,
+        0.1780671328306198,
+        0.309093177318573,
+        0.458683580160141,
+        0.14270278811454773,
+        0.3192795217037201,
+        0.34946882724761963,
+        0.369506299495697,
+        0.3466206192970276,
+        0.2951693832874298,
+        0.512150228023529,
+        0.425812304019928,
+        0.19491614401340485,
+        0.4425966441631317,
+        0.4880734384059906,
+        0.23327100276947021,
+        0.24540312588214874,
+        0.3959514796733856,
+        0.572983980178833,
+        0.36296698451042175,
+        0.1563234180212021,
+        0.15700078010559082,
+        0.19665764272212982,
+        0.3422546982765198,
+        0.34216558933258057,
+        0.3437070846557617,
+        0.3731553256511688,
+        0.41093921661376953,
+        0.42433691024780273,
+        0.3440423905849457,
+        0.2885344624519348,
+        0.2176325023174286,
+        0.30118075013160706,
+        0.21895116567611694,
+        0.3363306522369385,
+        0.2881864011287689,
+        0.3109566271305084,
+        0.5502058267593384,
+        0.19899773597717285,
+        0.37711605429649353,
+        0.19911745190620422,
+        0.24518877267837524,
+        0.5873903036117554,
+        0.3669925928115845,
+        0.45322027802467346,
+        0.1830274611711502,
+        0.4631514549255371,
+        0.3272465169429779,
+        0.3190767765045166,
+        0.4023485481739044,
+        0.26572510600090027,
+        0.35448575019836426,
+        0.29157865047454834,
+        0.43992626667022705,
+        0.22037973999977112,
+        0.3610759675502777,
+        0.22566869854927063,
+        0.23757776618003845,
+        0.5053218603134155,
+        0.4674651026725769,
+        0.6472631096839905,
+        0.5025660991668701,
+        0.15235765278339386,
+        0.19785749912261963,
+        0.20855219662189484,
+        0.36760589480400085,
+        0.4717724025249481,
+        0.3667448163032532,
+        0.31002289056777954,
+        0.38428932428359985,
+        0.39412227272987366,
+        0.4664827287197113,
+        0.2637614607810974,
+        0.39049017429351807,
+        0.41675034165382385,
+        0.30378878116607666,
+        0.3408553898334503,
+        0.3599216938018799,
+        0.42854785919189453,
+        0.36476433277130127,
+        0.15343733131885529,
+        0.3367450535297394,
+        0.1642351746559143,
+        0.30034878849983215,
+        0.21686823666095734,
+        0.2961113452911377,
+        0.4661010801792145,
+        0.2887129485607147,
+        0.27136844396591187,
+        0.3301190435886383,
+        0.3257361054420471,
+        0.22117461264133453,
+        0.33639076352119446,
+        0.2383575737476349,
+        0.2682618200778961,
+        0.3125735819339752,
+        0.3407227396965027,
+        0.4198980927467346,
+        0.23820869624614716
+    ],
+    "analytic_eif-one_step": [
+        0.34353700280189514,
+        0.13584259152412415,
+        0.36127716302871704,
+        0.15113501250743866,
+        0.27882128953933716,
+        0.1423613578081131,
+        0.06405952572822571,
+        0.3712005615234375,
+        0.13835936784744263,
+        0.16611404716968536,
+        0.24185031652450562,
+        0.28594306111335754,
+        0.1216767430305481,
+        0.06503324210643768,
+        0.15733659267425537,
+        0.26941221952438354,
+        0.22228166460990906,
+        0.1440175473690033,
+        0.4367375075817108,
+        0.26493746042251587,
+        0.41136711835861206,
+        0.010259732604026794,
+        0.2545619308948517,
+        0.11344790458679199,
+        0.30539238452911377,
+        0.24778860807418823,
+        0.2743147909641266,
+        0.1681550294160843,
+        0.05331215262413025,
+        0.24705490469932556,
+        0.3112924098968506,
+        0.17059417068958282,
+        0.2445177435874939,
+        0.20261558890342712,
+        0.37346112728118896,
+        0.17238087952136993,
+        0.1756667196750641,
+        0.28845158219337463,
+        0.17961084842681885,
+        0.15993772447109222,
+        0.6067849397659302,
+        0.17112401127815247,
+        0.41263389587402344,
+        0.2350786328315735,
+        0.1982877105474472,
+        -0.012186408042907715,
+        0.3428800702095032,
+        0.2197500765323639,
+        0.2696734666824341,
+        0.08713576197624207,
+        0.22755663096904755,
+        0.19966742396354675,
+        0.26737338304519653,
+        0.10679563879966736,
+        0.32873862981796265,
+        0.26920491456985474,
+        0.3943629860877991,
+        0.3750118613243103,
+        0.31667327880859375,
+        0.28761085867881775,
+        0.30544939637184143,
+        0.11848920583724976,
+        0.11486601829528809,
+        0.17888201773166656,
+        0.21536558866500854,
+        0.23146675527095795,
+        0.3208797872066498,
+        0.04642191529273987,
+        0.04861673712730408,
+        0.24245290458202362,
+        0.1223706603050232,
+        0.2452482432126999,
+        0.1822974979877472,
+        0.08586792647838593,
+        0.2604559659957886,
+        0.14748501777648926,
+        0.28919723629951477,
+        0.3047313988208771,
+        0.38353487849235535,
+        0.19043558835983276,
+        0.2552395462989807,
+        0.18827350437641144,
+        0.13185745477676392,
+        0.08581338077783585,
+        -0.03463560342788696,
+        0.3274173140525818,
+        0.29686519503593445,
+        0.246217280626297,
+        0.30773651599884033,
+        0.27545028924942017,
+        0.11580538749694824,
+        0.1547469198703766,
+        0.32753315567970276,
+        0.3246723413467407,
+        0.07220754027366638,
+        0.25920385122299194,
+        0.43208712339401245,
+        0.19863197207450867,
+        0.24285081028938293,
+        0.14414356648921967
+    ],
+    "analytic_eif-double_ml": [
+        0.6361349821090698,
+        0.5309189856052399,
+        0.9158359318971634,
+        0.7087532132863998,
+        0.8173158764839172,
+        0.6751835569739342,
+        0.4823194742202759,
+        0.9330247044563293,
+        0.7448698878288269,
+        0.5200318247079849,
+        0.8224777281284332,
+        0.699287623167038,
+        0.5718091130256653,
+        0.5177016705274582,
+        0.5459288358688354,
+        0.8066826462745667,
+        0.7433740049600601,
+        0.6001838147640228,
+        0.9106434285640717,
+        0.6786685585975647,
+        0.9169524013996124,
+        0.4951963275671005,
+        0.8120758682489395,
+        0.6665371954441071,
+        0.781407356262207,
+        0.9903062283992767,
+        0.6714800298213959,
+        0.7720862179994583,
+        0.6427560746669769,
+        0.8552378118038177,
+        0.8470920622348785,
+        0.6630908995866776,
+        0.6561408638954163,
+        0.6787867248058319,
+        0.7898553758859634,
+        0.6569745391607285,
+        0.7045330703258514,
+        0.7726262509822845,
+        0.6773330569267273,
+        0.7441492974758148,
+        1.0908786058425903,
+        0.5965169966220856,
+        1.0021242052316666,
+        0.7290205359458923,
+        0.6613835543394089,
+        0.5153348445892334,
+        0.7640452533960342,
+        0.7928963005542755,
+        0.7241942882537842,
+        0.4839417636394501,
+        0.7323970347642899,
+        0.7487899661064148,
+        0.7685292363166809,
+        0.5243690013885498,
+        0.8970370590686798,
+        0.850658044219017,
+        0.8084072172641754,
+        0.7975745797157288,
+        0.7716194540262222,
+        0.8063054978847504,
+        0.8272348940372467,
+        0.5709719657897949,
+        0.4908824563026428,
+        0.6552877575159073,
+        0.7610478848218918,
+        0.6964351385831833,
+        0.8935368061065674,
+        0.5778515934944153,
+        0.583708256483078,
+        0.7840211540460587,
+        0.6533748209476471,
+        0.8121792823076248,
+        0.688183456659317,
+        0.7039596289396286,
+        0.7151157259941101,
+        0.7607858777046204,
+        0.7027317583560944,
+        0.7864372730255127,
+        0.8293084502220154,
+        0.904606431722641,
+        0.7980606555938721,
+        0.8397910445928574,
+        0.6480499505996704,
+        0.6134044006466866,
+        0.45798832178115845,
+        0.7531958073377609,
+        0.7424699068069458,
+        0.5738276839256287,
+        0.8450541496276855,
+        0.8704737722873688,
+        0.6173290610313416,
+        0.605359673500061,
+        0.9669099748134613,
+        0.802715003490448,
+        0.6141620576381683,
+        0.7771597802639008,
+        0.9638209044933319,
+        0.7258258759975433,
+        0.7045946717262268,
+        0.6474638730287552
+    ],
+    "monte_carlo_eif-tmle": [
+        0.3155955672264099,
+        0.12997934222221375,
+        0.20883847773075104,
+        0.3270210325717926,
+        0.49054190516471863,
+        0.1453614979982376,
+        0.33265239000320435,
+        0.3326042890548706,
+        0.33840954303741455,
+        0.37711814045906067,
+        0.28450721502304077,
+        0.5187819600105286,
+        0.4033525288105011,
+        0.18305093050003052,
+        0.42360472679138184,
+        0.46743232011795044,
+        0.2725902497768402,
+        0.24055863916873932,
+        0.3730815052986145,
+        0.5657938718795776,
+        0.34321627020835876,
+        0.1875062733888626,
+        0.1575453281402588,
+        0.20332394540309906,
+        0.3585251569747925,
+        0.339942067861557,
+        0.3490593731403351,
+        0.3534829616546631,
+        0.4144774377346039,
+        0.44729042053222656,
+        0.35336554050445557,
+        0.29882264137268066,
+        0.21189936995506287,
+        0.2798171639442444,
+        0.24114775657653809,
+        0.3190464675426483,
+        0.2775978147983551,
+        0.32670706510543823,
+        0.5442466139793396,
+        0.2352093756198883,
+        0.36977940797805786,
+        0.22053493559360504,
+        0.2218434363603592,
+        0.6146228909492493,
+        0.38115185499191284,
+        0.4502531886100769,
+        0.2135109156370163,
+        0.4553815424442291,
+        0.3162468671798706,
+        0.3212607502937317,
+        0.411346971988678,
+        0.30455929040908813,
+        0.3375064432621002,
+        0.32896342873573303,
+        0.45161035656929016,
+        0.2122500240802765,
+        0.3787088394165039,
+        0.2121228724718094,
+        0.2642918825149536,
+        0.5285912156105042,
+        0.4681228995323181,
+        0.6546052098274231,
+        0.46523159742355347,
+        0.14528605341911316,
+        0.17726370692253113,
+        0.20050464570522308,
+        0.3707367181777954,
+        0.46002626419067383,
+        0.3755575716495514,
+        0.2895314693450928,
+        0.38197779655456543,
+        0.42401689291000366,
+        0.42389243841171265,
+        0.28902745246887207,
+        0.3791349530220032,
+        0.41283154487609863,
+        0.3118334114551544,
+        0.314208984375,
+        0.34356480836868286,
+        0.44577836990356445,
+        0.33902984857559204,
+        0.14284539222717285,
+        0.3357377350330353,
+        0.1560792773962021,
+        0.3127923905849457,
+        0.20744819939136505,
+        0.31365346908569336,
+        0.435160756111145,
+        0.29514557123184204,
+        0.2655172049999237,
+        0.36706283688545227,
+        0.30309945344924927,
+        0.22880253195762634,
+        0.34706076979637146,
+        0.25253140926361084,
+        0.27676716446876526,
+        0.3239942789077759,
+        0.3127383589744568,
+        0.42953822016716003,
+        0.2821480631828308
+    ],
+    "monte_carlo_eif-one_step": [
+        0.35389941930770874,
+        0.12066487222909927,
+        0.3272823095321655,
+        0.16992847621440887,
+        0.28082412481307983,
+        0.11357730627059937,
+        0.09033170342445374,
+        0.36031511425971985,
+        0.16861987113952637,
+        0.17305417358875275,
+        0.22208906710147858,
+        0.2634490728378296,
+        0.1412336826324463,
+        0.08644792437553406,
+        0.16948935389518738,
+        0.226078063249588,
+        0.22199749946594238,
+        0.1070089042186737,
+        0.40926358103752136,
+        0.1891499161720276,
+        0.3888532817363739,
+        0.01757611334323883,
+        0.22711563110351562,
+        0.15685753524303436,
+        0.3101191520690918,
+        0.23816123604774475,
+        0.2897639274597168,
+        0.15883100032806396,
+        0.07443976402282715,
+        0.2450403869152069,
+        0.30531036853790283,
+        0.15060684084892273,
+        0.2828177511692047,
+        0.2171541452407837,
+        0.3851669430732727,
+        0.1901264786720276,
+        0.17384007573127747,
+        0.2987920641899109,
+        0.16489866375923157,
+        0.17583397030830383,
+        0.5671582818031311,
+        0.18640074133872986,
+        0.38012346625328064,
+        0.2844260036945343,
+        0.19556564092636108,
+        -0.035295337438583374,
+        0.3175429105758667,
+        0.24713431298732758,
+        0.24698291718959808,
+        0.08802415430545807,
+        0.23395343124866486,
+        0.18231052160263062,
+        0.28385794162750244,
+        0.12243841588497162,
+        0.327273964881897,
+        0.25112035870552063,
+        0.39117470383644104,
+        0.3667139410972595,
+        0.29749974608421326,
+        0.23334291577339172,
+        0.29140663146972656,
+        0.05932044982910156,
+        0.11683085560798645,
+        0.16100558638572693,
+        0.19129854440689087,
+        0.20573341846466064,
+        0.32739129662513733,
+        0.07700455188751221,
+        0.07302576303482056,
+        0.24367770552635193,
+        0.1342063844203949,
+        0.2524726688861847,
+        0.1825893223285675,
+        0.09149438142776489,
+        0.2756613492965698,
+        0.16756439208984375,
+        0.2940676510334015,
+        0.2916421890258789,
+        0.41005298495292664,
+        0.1777900755405426,
+        0.276382178068161,
+        0.1930345892906189,
+        0.1170177310705185,
+        0.0761890709400177,
+        -0.0753144919872284,
+        0.34296107292175293,
+        0.29970791935920715,
+        0.24088823795318604,
+        0.3255411684513092,
+        0.2487124800682068,
+        0.15751716494560242,
+        0.13011175394058228,
+        0.327239990234375,
+        0.3215688467025757,
+        0.05291299521923065,
+        0.2784276306629181,
+        0.4723959267139435,
+        0.19121208786964417,
+        0.21731945872306824,
+        0.1587335169315338
+    ],
+    "monte_carlo_eif-double_ml": [
+        0.6464973986148834,
+        0.515741266310215,
+        0.8818410784006119,
+        0.7275466769933701,
+        0.8193187117576599,
+        0.6463995054364204,
+        0.5085916519165039,
+        0.9221392571926117,
+        0.7751303911209106,
+        0.5269719511270523,
+        0.8027164787054062,
+        0.67679363489151,
+        0.5913660526275635,
+        0.5391163527965546,
+        0.5580815970897675,
+        0.7633484899997711,
+        0.7430898398160934,
+        0.5631751716136932,
+        0.8831695020198822,
+        0.6028810143470764,
+        0.8944385647773743,
+        0.5025127083063126,
+        0.7846295684576035,
+        0.7099468261003494,
+        0.7861341238021851,
+        0.9806788563728333,
+        0.6869291663169861,
+        0.762762188911438,
+        0.6638836860656738,
+        0.8532232940196991,
+        0.8411100208759308,
+        0.6431035697460175,
+        0.6944408714771271,
+        0.6933252811431885,
+        0.8015611916780472,
+        0.6747201383113861,
+        0.7027064263820648,
+        0.7829667329788208,
+        0.66262087225914,
+        0.7600455433130264,
+        1.0512519478797913,
+        0.611793726682663,
+        0.9696137756109238,
+        0.7783679068088531,
+        0.6586614847183228,
+        0.49222591519355774,
+        0.7387080937623978,
+        0.8202805370092392,
+        0.7015037387609482,
+        0.4848301559686661,
+        0.7387938350439072,
+        0.7314330637454987,
+        0.7850137948989868,
+        0.5400117784738541,
+        0.8955723941326141,
+        0.8325734883546829,
+        0.8052189350128174,
+        0.789276659488678,
+        0.7524459213018417,
+        0.7520375549793243,
+        0.8131921291351318,
+        0.5118032097816467,
+        0.4928472936153412,
+        0.6374113261699677,
+        0.7369808405637741,
+        0.670701801776886,
+        0.9000483155250549,
+        0.6084342300891876,
+        0.6081172823905945,
+        0.785245954990387,
+        0.6652105450630188,
+        0.8194037079811096,
+        0.6884752810001373,
+        0.7095860838890076,
+        0.7303211092948914,
+        0.7808652520179749,
+        0.7076021730899811,
+        0.7733480632305145,
+        0.8558265566825867,
+        0.8919609189033508,
+        0.8192032873630524,
+        0.8445521295070648,
+        0.633210226893425,
+        0.6037800908088684,
+        0.417309433221817,
+        0.7687395662069321,
+        0.7453126311302185,
+        0.5684986412525177,
+        0.8628588020801544,
+        0.8437359631061554,
+        0.6590408384799957,
+        0.5807245075702667,
+        0.9666168093681335,
+        0.799611508846283,
+        0.5948675125837326,
+        0.7963835597038269,
+        1.004129707813263,
+        0.7184059917926788,
+        0.6790633201599121,
+        0.6620538234710693
+    ],
+    "plug-in-mle-from-model": [
+        0.29303088784217834,
+        0.16591405868530273,
+        0.1615283340215683,
+        0.3347514867782593,
+        0.48925507068634033,
+        0.10964994877576828,
+        0.3111332952976227,
+        0.3290335536003113,
+        0.34723520278930664,
+        0.3917902112007141,
+        0.331586092710495,
+        0.5071767568588257,
+        0.4482594132423401,
+        0.20763325691223145,
+        0.4439792037010193,
+        0.4998875856399536,
+        0.2433425337076187,
+        0.2581843137741089,
+        0.38689935207366943,
+        0.5970532894134521,
+        0.3297704756259918,
+        0.1574830412864685,
+        0.14008547365665436,
+        0.22331777215003967,
+        0.3969348669052124,
+        0.35803231596946716,
+        0.34050214290618896,
+        0.38944780826568604,
+        0.4019252061843872,
+        0.4624779224395752,
+        0.3412792384624481,
+        0.310230016708374,
+        0.209136962890625,
+        0.3130667209625244,
+        0.20723508298397064,
+        0.32483574748039246,
+        0.2931257486343384,
+        0.3167368173599243,
+        0.5223131775856018,
+        0.19896377623081207,
+        0.37878167629241943,
+        0.2266479730606079,
+        0.2115226835012436,
+        0.6411014795303345,
+        0.3979807496070862,
+        0.472644567489624,
+        0.21288113296031952,
+        0.48229551315307617,
+        0.32302606105804443,
+        0.3556915521621704,
+        0.38511231541633606,
+        0.3122364580631256,
+        0.3662373423576355,
+        0.33023765683174133,
+        0.47563114762306213,
+        0.22208483517169952,
+        0.37216296792030334,
+        0.20084387063980103,
+        0.21159575879573822,
+        0.5526059865951538,
+        0.474670946598053,
+        0.6805239319801331,
+        0.5023016333580017,
+        0.17324042320251465,
+        0.17706646025180817,
+        0.23558706045150757,
+        0.39317330718040466,
+        0.44017210602760315,
+        0.3797096014022827,
+        0.2932527959346771,
+        0.41001781821250916,
+        0.4348998963832855,
+        0.4578908681869507,
+        0.28075897693634033,
+        0.43518924713134766,
+        0.4283755421638489,
+        0.311260461807251,
+        0.3089047968387604,
+        0.37665286660194397,
+        0.43311020731925964,
+        0.3805909752845764,
+        0.15232667326927185,
+        0.34888797998428345,
+        0.16224858164787292,
+        0.3169839382171631,
+        0.16351719200611115,
+        0.319029301404953,
+        0.44582250714302063,
+        0.282720685005188,
+        0.2622433006763458,
+        0.34118038415908813,
+        0.3215940296649933,
+        0.20642822980880737,
+        0.34262216091156006,
+        0.245849609375,
+        0.28617408871650696,
+        0.300485223531723,
+        0.32751673460006714,
+        0.44511309266090393,
+        0.26790669560432434
+    ],
+    "plug-in-mle-from-test": [
+        0.585628867149353,
+        0.5609904527664185,
+        0.7160871028900146,
+        0.8923696875572205,
+        1.0277496576309204,
+        0.6424721479415894,
+        0.7293932437896729,
+        0.8908576965332031,
+        0.9537457227706909,
+        0.7457079887390137,
+        0.9122135043144226,
+        0.9205213189125061,
+        0.8983917832374573,
+        0.660301685333252,
+        0.8325714468955994,
+        1.0371580123901367,
+        0.7644348740577698,
+        0.7143505811691284,
+        0.8608052730560303,
+        1.010784387588501,
+        0.8353557586669922,
+        0.6424196362495422,
+        0.6975994110107422,
+        0.7764070630073547,
+        0.8729498386383057,
+        1.1005499362945557,
+        0.7376673817634583,
+        0.9933789968490601,
+        0.9913691282272339,
+        1.0706608295440674,
+        0.8770788908004761,
+        0.8027267456054688,
+        0.6207600831985474,
+        0.7892378568649292,
+        0.6236293315887451,
+        0.809429407119751,
+        0.8219920992851257,
+        0.8009114861488342,
+        1.0200353860855103,
+        0.7831753492355347,
+        0.8628753423690796,
+        0.652040958404541,
+        0.8010129928588867,
+        1.1350433826446533,
+        0.8610765933990479,
+        1.0001658201217651,
+        0.6340463161468506,
+        1.0554417371749878,
+        0.7775468826293945,
+        0.7524975538253784,
+        0.8899527192115784,
+        0.8613590002059937,
+        0.8673931956291199,
+        0.7478110194206238,
+        1.0439295768737793,
+        0.8035379648208618,
+        0.7862071990966797,
+        0.6234065890312195,
+        0.6665419340133667,
+        1.0713006258010864,
+        0.9964564442634583,
+        1.1330066919326782,
+        0.8783180713653564,
+        0.6496461629867554,
+        0.7227487564086914,
+        0.7005554437637329,
+        0.9658303260803223,
+        0.9716017842292786,
+        0.9148011207580566,
+        0.8348210453987122,
+        0.9410219788551331,
+        1.0018309354782104,
+        0.9637768268585205,
+        0.898850679397583,
+        0.8898490071296692,
+        1.04167640209198,
+        0.7247949838638306,
+        0.790610671043396,
+        0.822426438331604,
+        1.1472810506820679,
+        0.9234120845794678,
+        0.8038442134857178,
+        0.8650804758071899,
+        0.6898396015167236,
+        0.8096078634262085,
+        0.5892956852912903,
+        0.7646340131759644,
+        0.7734329104423523,
+        0.8200383186340332,
+        0.8572667837142944,
+        0.8427040576934814,
+        0.7722067832946777,
+        0.8458050489425659,
+        0.8206648230552673,
+        0.787804126739502,
+        0.8041300177574158,
+        0.8322190046310425,
+        0.8547106385231018,
+        0.9068569540977478,
+        0.7712270021438599
+    ]
+}
\ No newline at end of file
diff --git a/docs/examples/robust_paper/results/ate_causal_glm_ihdp.json b/docs/examples/robust_paper/results/ate_causal_glm_ihdp.json
new file mode 100644
index 00000000..c7ad0a5a
--- /dev/null
+++ b/docs/examples/robust_paper/results/ate_causal_glm_ihdp.json
@@ -0,0 +1,754 @@
+{
+    "analytic_eif-tmle": [
+        3.839876651763916,
+        3.5331175327301025,
+        3.824369430541992,
+        3.714146375656128,
+        3.6636526584625244,
+        3.807866334915161,
+        3.7564496994018555,
+        3.8284895420074463,
+        3.783723831176758,
+        3.826263189315796,
+        3.9330756664276123,
+        3.898710250854492,
+        3.7766313552856445,
+        3.926036834716797,
+        3.774528980255127,
+        3.792569637298584,
+        3.9387059211730957,
+        3.869884490966797,
+        3.813490629196167,
+        3.7400593757629395,
+        3.7688889503479004,
+        3.9319093227386475,
+        3.815572738647461,
+        3.813718795776367,
+        3.817241907119751,
+        3.8288776874542236,
+        3.7090296745300293,
+        3.775740623474121,
+        3.83687424659729,
+        3.7990338802337646,
+        3.846245288848877,
+        3.7503819465637207,
+        3.8264317512512207,
+        3.775503158569336,
+        4.079380989074707,
+        3.835303544998169,
+        3.7560348510742188,
+        3.669255495071411,
+        3.9737491607666016,
+        3.903839111328125,
+        3.856783866882324,
+        3.8265018463134766,
+        3.959981918334961,
+        3.7979114055633545,
+        3.642767906188965,
+        3.8436360359191895,
+        3.7808656692504883,
+        3.812312602996826,
+        3.8355937004089355,
+        3.8291714191436768,
+        3.74246883392334,
+        3.751783609390259,
+        3.8517889976501465,
+        3.828932046890259,
+        3.8153371810913086,
+        3.8854141235351562,
+        3.723742961883545,
+        3.635148048400879,
+        3.7152202129364014,
+        3.821760892868042,
+        3.687731981277466,
+        3.762479782104492,
+        3.928602457046509,
+        3.8235721588134766,
+        3.671370029449463,
+        4.005984306335449,
+        3.800032138824463,
+        4.003036022186279,
+        3.968428611755371,
+        3.5957930088043213,
+        3.753859281539917,
+        3.8993799686431885,
+        3.9322030544281006,
+        3.762279748916626,
+        3.896578073501587,
+        3.880298137664795,
+        3.7625906467437744,
+        3.8666727542877197,
+        3.7621495723724365,
+        3.835761785507202,
+        3.7722573280334473,
+        3.7797532081604004,
+        3.73939847946167,
+        3.648416757583618,
+        3.783208131790161,
+        3.939659833908081,
+        3.6872305870056152,
+        3.707148790359497,
+        3.7717959880828857,
+        3.742614507675171,
+        3.743137836456299,
+        3.966012954711914
+    ],
+    "analytic_eif-one_step": [
+        3.721874952316284,
+        3.975658416748047,
+        3.9216268062591553,
+        3.9260659217834473,
+        3.825951099395752,
+        3.8630897998809814,
+        3.6129796504974365,
+        3.7774622440338135,
+        3.764096260070801,
+        4.0642242431640625,
+        3.9206931591033936,
+        3.708268880844116,
+        3.8033692836761475,
+        3.61521053314209,
+        3.8424928188323975,
+        3.8446383476257324,
+        3.742774486541748,
+        3.9857912063598633,
+        3.8339502811431885,
+        3.8535807132720947,
+        3.7041821479797363,
+        3.7423958778381348,
+        3.8546664714813232,
+        3.681549310684204,
+        3.790097236633301,
+        3.7919178009033203,
+        3.7309834957122803,
+        3.7336056232452393,
+        3.772038221359253,
+        3.646641731262207,
+        3.83508563041687,
+        3.8592569828033447,
+        3.9166219234466553,
+        3.641303777694702,
+        3.8352620601654053,
+        3.756117105484009,
+        3.7782461643218994,
+        3.762101173400879,
+        3.813594341278076,
+        3.800577163696289,
+        3.8008339405059814,
+        3.8193061351776123,
+        3.6668291091918945,
+        3.7877986431121826,
+        3.989220142364502,
+        3.7240705490112305,
+        3.663825511932373,
+        3.8209128379821777,
+        3.992730140686035,
+        3.7217791080474854,
+        4.0137248039245605,
+        3.6028823852539062,
+        3.8582751750946045,
+        3.822843551635742,
+        4.065920352935791,
+        3.9217162132263184,
+        3.7659502029418945,
+        3.926132917404175,
+        4.1629414558410645,
+        3.82395339012146,
+        3.9751172065734863,
+        3.8031115531921387,
+        3.7366745471954346,
+        3.842092990875244,
+        3.693372964859009,
+        3.668882131576538,
+        3.8136448860168457,
+        3.769430160522461,
+        3.5914463996887207,
+        3.9516713619232178,
+        3.984814167022705,
+        3.6749980449676514,
+        3.8262548446655273,
+        3.8703784942626953,
+        3.7231106758117676,
+        3.82120943069458,
+        3.629378318786621,
+        3.9481682777404785,
+        3.6560351848602295,
+        3.737612009048462,
+        3.9032130241394043,
+        3.976604461669922,
+        3.8223748207092285,
+        3.812610387802124,
+        3.7458157539367676,
+        3.6460907459259033,
+        3.630096912384033,
+        3.9932749271392822,
+        3.7783010005950928,
+        3.9974801540374756,
+        3.632181167602539,
+        3.7163143157958984
+    ],
+    "analytic_eif-double_ml": [
+        3.9292688369750977,
+        4.124208211898804,
+        3.9386284351348877,
+        4.169655084609985,
+        3.9546031951904297,
+        4.155849933624268,
+        3.737276077270508,
+        3.9722847938537598,
+        4.016973972320557,
+        4.338471412658691,
+        4.156325578689575,
+        3.8916049003601074,
+        4.047196865081787,
+        3.736837863922119,
+        3.9895451068878174,
+        4.085540771484375,
+        4.034946441650391,
+        4.130852699279785,
+        3.9660797119140625,
+        4.001047611236572,
+        3.739079236984253,
+        3.926154375076294,
+        4.017667770385742,
+        3.6437203884124756,
+        3.9009134769439697,
+        3.930450201034546,
+        3.887011766433716,
+        3.9119513034820557,
+        3.831204891204834,
+        3.699113130569458,
+        3.9883298873901367,
+        3.9441864490509033,
+        4.158538579940796,
+        3.7595293521881104,
+        4.035249471664429,
+        4.083334684371948,
+        3.890502452850342,
+        3.874842882156372,
+        4.13043212890625,
+        3.984645128250122,
+        4.146570205688477,
+        4.018994092941284,
+        3.668405771255493,
+        4.021650791168213,
+        4.106330394744873,
+        3.899179458618164,
+        3.698827028274536,
+        4.068745851516724,
+        4.138624668121338,
+        3.879589796066284,
+        4.225254058837891,
+        3.7937934398651123,
+        4.028165578842163,
+        3.864980936050415,
+        4.3509838581085205,
+        4.065845727920532,
+        3.8496155738830566,
+        4.086026191711426,
+        4.440109014511108,
+        3.988475799560547,
+        4.182727813720703,
+        3.913755416870117,
+        3.9225683212280273,
+        3.8545446395874023,
+        3.767693042755127,
+        3.817678689956665,
+        3.9067561626434326,
+        3.9560017585754395,
+        3.8408493995666504,
+        4.150688171386719,
+        3.995961904525757,
+        3.8178625106811523,
+        4.012617588043213,
+        4.028895616531372,
+        4.006508111953735,
+        3.946417808532715,
+        3.704528331756592,
+        4.180272817611694,
+        3.8766772747039795,
+        3.861259937286377,
+        4.109742164611816,
+        4.206973552703857,
+        3.9652535915374756,
+        3.9604859352111816,
+        3.881007194519043,
+        3.7359368801116943,
+        3.7266061305999756,
+        4.065619945526123,
+        3.8301949501037598,
+        4.122846841812134,
+        3.790860176086426,
+        3.8152713775634766
+    ],
+    "monte_carlo_eif-tmle": [
+        3.8681862354278564,
+        3.516026258468628,
+        3.8115952014923096,
+        3.6937031745910645,
+        3.6634702682495117,
+        3.8138515949249268,
+        3.7369844913482666,
+        3.806765556335449,
+        3.7736198902130127,
+        3.8267769813537598,
+        3.938678026199341,
+        3.865253448486328,
+        3.759643316268921,
+        3.9090445041656494,
+        3.8068277835845947,
+        3.8100836277008057,
+        3.9625961780548096,
+        3.8734874725341797,
+        3.818157911300659,
+        3.7291526794433594,
+        3.7733206748962402,
+        3.8664772510528564,
+        3.823476552963257,
+        3.8070225715637207,
+        3.7958805561065674,
+        3.8245294094085693,
+        3.7105350494384766,
+        3.751678228378296,
+        3.7783825397491455,
+        3.8153445720672607,
+        3.8622500896453857,
+        3.7652499675750732,
+        3.830846071243286,
+        3.7687015533447266,
+        4.074945449829102,
+        3.881787061691284,
+        3.769089937210083,
+        3.6389219760894775,
+        3.9601340293884277,
+        3.9025206565856934,
+        3.882110834121704,
+        3.8108179569244385,
+        3.93050479888916,
+        3.775953531265259,
+        3.6587061882019043,
+        3.838216781616211,
+        3.7784183025360107,
+        3.807610273361206,
+        3.823448419570923,
+        3.8080248832702637,
+        3.747066020965576,
+        3.733949899673462,
+        3.8482425212860107,
+        3.8545985221862793,
+        3.7852272987365723,
+        3.8924379348754883,
+        3.7472195625305176,
+        3.6252167224884033,
+        3.697585105895996,
+        3.8045034408569336,
+        3.7097625732421875,
+        3.7676098346710205,
+        3.904839515686035,
+        3.819328546524048,
+        3.6732118129730225,
+        4.026763439178467,
+        3.7722132205963135,
+        4.014700412750244,
+        3.9996402263641357,
+        3.59531831741333,
+        3.7544074058532715,
+        3.9382550716400146,
+        3.9497456550598145,
+        3.7660555839538574,
+        3.885580062866211,
+        3.8767647743225098,
+        3.7534098625183105,
+        3.873401165008545,
+        3.7678563594818115,
+        3.8537254333496094,
+        3.7630035877227783,
+        3.765357732772827,
+        3.778564929962158,
+        3.630566358566284,
+        3.8319356441497803,
+        3.9698851108551025,
+        3.6790788173675537,
+        3.6781976222991943,
+        3.7864577770233154,
+        3.728658676147461,
+        3.7527639865875244,
+        3.974327325820923
+    ],
+    "monte_carlo_eif-one_step": [
+        3.7633237838745117,
+        3.974067211151123,
+        3.920567035675049,
+        3.896141767501831,
+        3.792893171310425,
+        3.8287408351898193,
+        3.6751503944396973,
+        3.7884209156036377,
+        3.7959036827087402,
+        4.041287422180176,
+        3.907686710357666,
+        3.7248659133911133,
+        3.8704638481140137,
+        3.6651365756988525,
+        3.818131446838379,
+        3.8078079223632812,
+        3.7972726821899414,
+        3.9758620262145996,
+        3.843653917312622,
+        3.8471624851226807,
+        3.735469341278076,
+        3.7776272296905518,
+        3.8467626571655273,
+        3.7519569396972656,
+        3.8544809818267822,
+        3.8233768939971924,
+        3.7427616119384766,
+        3.743400812149048,
+        3.8080549240112305,
+        3.7174954414367676,
+        3.8533682823181152,
+        3.8481802940368652,
+        3.899125576019287,
+        3.6569623947143555,
+        3.8878183364868164,
+        3.7652621269226074,
+        3.766897678375244,
+        3.8023297786712646,
+        3.8299384117126465,
+        3.7953238487243652,
+        3.826266050338745,
+        3.829505205154419,
+        3.709527015686035,
+        3.782870054244995,
+        3.997131824493408,
+        3.743642568588257,
+        3.7085444927215576,
+        3.8262922763824463,
+        4.030390739440918,
+        3.7333991527557373,
+        4.026367664337158,
+        3.626141309738159,
+        3.8590316772460938,
+        3.8490657806396484,
+        4.079745769500732,
+        3.893465042114258,
+        3.7839794158935547,
+        3.901862859725952,
+        4.142735481262207,
+        3.859386682510376,
+        3.9587414264678955,
+        3.8247289657592773,
+        3.7813611030578613,
+        3.8250248432159424,
+        3.7045888900756836,
+        3.7228901386260986,
+        3.840918779373169,
+        3.810554265975952,
+        3.6413075923919678,
+        3.9567956924438477,
+        4.008106231689453,
+        3.7361464500427246,
+        3.8361880779266357,
+        3.8709475994110107,
+        3.7831151485443115,
+        3.8360226154327393,
+        3.712047576904297,
+        3.95611310005188,
+        3.706984281539917,
+        3.767472267150879,
+        3.8629326820373535,
+        4.012974262237549,
+        3.8426246643066406,
+        3.8142032623291016,
+        3.7750062942504883,
+        3.6359353065490723,
+        3.70906138420105,
+        3.9873244762420654,
+        3.7685766220092773,
+        4.022496223449707,
+        3.6586055755615234,
+        3.7576844692230225
+    ],
+    "monte_carlo_eif-double_ml": [
+        3.970717668533325,
+        4.12261700630188,
+        3.9375686645507812,
+        4.139730930328369,
+        3.9215452671051025,
+        4.1215009689331055,
+        3.7994468212127686,
+        3.983243465423584,
+        4.048781394958496,
+        4.315534591674805,
+        4.143319129943848,
+        3.9082019329071045,
+        4.114291429519653,
+        3.786763906478882,
+        3.965183734893799,
+        4.048710346221924,
+        4.089444637298584,
+        4.1209235191345215,
+        3.975783348083496,
+        3.994629383087158,
+        3.7703664302825928,
+        3.961385726928711,
+        4.009763956069946,
+        3.714128017425537,
+        3.965297222137451,
+        3.961909294128418,
+        3.898789882659912,
+        3.9217464923858643,
+        3.8672215938568115,
+        3.7699668407440186,
+        4.006612539291382,
+        3.933109760284424,
+        4.141042232513428,
+        3.7751879692077637,
+        4.08780574798584,
+        4.092479705810547,
+        3.8791539669036865,
+        3.915071487426758,
+        4.14677619934082,
+        3.9793918132781982,
+        4.17200231552124,
+        4.029193162918091,
+        3.711103677749634,
+        4.016722202301025,
+        4.114242076873779,
+        3.9187514781951904,
+        3.7435460090637207,
+        4.074125289916992,
+        4.176285266876221,
+        3.891209840774536,
+        4.237896919250488,
+        3.8170523643493652,
+        4.028922080993652,
+        3.8912031650543213,
+        4.364809274673462,
+        4.037594556808472,
+        3.867644786834717,
+        4.061756134033203,
+        4.419903039932251,
+        4.023909091949463,
+        4.166352033615112,
+        3.935372829437256,
+        3.967254877090454,
+        3.8374764919281006,
+        3.7789089679718018,
+        3.8716866970062256,
+        3.934030055999756,
+        3.9971258640289307,
+        3.8907105922698975,
+        4.155812501907349,
+        4.019253969192505,
+        3.8790109157562256,
+        4.022550821304321,
+        4.0294647216796875,
+        4.066512584686279,
+        3.961230993270874,
+        3.7871975898742676,
+        4.188217639923096,
+        3.927626371383667,
+        3.891120195388794,
+        4.069461822509766,
+        4.243343353271484,
+        3.9855034351348877,
+        3.962078809738159,
+        3.9101977348327637,
+        3.7257814407348633,
+        3.805570602416992,
+        4.059669494628906,
+        3.8204705715179443,
+        4.147862911224365,
+        3.81728458404541,
+        3.8566415309906006
+    ],
+    "plug-in-mle-from-model": [
+        3.8888871669769287,
+        3.4957659244537354,
+        3.793285846710205,
+        3.6561882495880127,
+        3.6290812492370605,
+        3.792243719100952,
+        3.797788619995117,
+        3.8203046321868896,
+        3.810659408569336,
+        3.7938194274902344,
+        3.924154758453369,
+        3.9132726192474365,
+        3.765573740005493,
+        3.925321102142334,
+        3.782444953918457,
+        3.7914586067199707,
+        3.9850382804870605,
+        3.852663278579712,
+        3.7967936992645264,
+        3.675572633743286,
+        3.7768311500549316,
+        3.9280741214752197,
+        3.791006326675415,
+        3.836116313934326,
+        3.770336627960205,
+        3.8537957668304443,
+        3.6922507286071777,
+        3.7645535469055176,
+        3.834435224533081,
+        3.8319828510284424,
+        3.8764665126800537,
+        3.766538619995117,
+        3.8184218406677246,
+        3.7937653064727783,
+        4.087764739990234,
+        3.8645777702331543,
+        3.770695209503174,
+        3.6018083095550537,
+        3.986194133758545,
+        3.8974063396453857,
+        3.89853835105896,
+        3.7841391563415527,
+        3.9648890495300293,
+        3.7817022800445557,
+        3.6197214126586914,
+        3.8577919006347656,
+        3.7943789958953857,
+        3.798537492752075,
+        3.7980518341064453,
+        3.831646203994751,
+        3.715691089630127,
+        3.7825160026550293,
+        3.874286651611328,
+        3.8564281463623047,
+        3.79241681098938,
+        3.825185537338257,
+        3.7039670944213867,
+        3.5995562076568604,
+        3.723207712173462,
+        3.7994840145111084,
+        3.6833653450012207,
+        3.7401461601257324,
+        3.9400813579559326,
+        3.7679452896118164,
+        3.6722140312194824,
+        4.046419620513916,
+        3.748612880706787,
+        4.036281108856201,
+        4.015773773193359,
+        3.579007387161255,
+        3.714299201965332,
+        3.944594144821167,
+        3.933716297149658,
+        3.753580093383789,
+        3.917356252670288,
+        3.868974208831787,
+        3.774965286254883,
+        3.8547894954681396,
+        3.737250804901123,
+        3.867110252380371,
+        3.7647109031677246,
+        3.707094192504883,
+        3.722935199737549,
+        3.6000351905822754,
+        3.8150687217712402,
+        3.97530460357666,
+        3.672628879547119,
+        3.677774667739868,
+        3.806727647781372,
+        3.712677240371704,
+        3.7888519763946533,
+        4.022754669189453
+    ],
+    "plug-in-mle-from-test": [
+        4.096281051635742,
+        3.644315719604492,
+        3.8102874755859375,
+        3.899777412414551,
+        3.7577333450317383,
+        4.085003852844238,
+        3.9220850467681885,
+        4.015127182006836,
+        4.063537120819092,
+        4.068066596984863,
+        4.159787178039551,
+        4.096608638763428,
+        4.009401321411133,
+        4.046948432922363,
+        3.929497241973877,
+        4.032361030578613,
+        4.277210235595703,
+        3.997724771499634,
+        3.9289231300354004,
+        3.8230395317077637,
+        3.8117282390594482,
+        4.111832618713379,
+        3.954007625579834,
+        3.7982873916625977,
+        3.881152868270874,
+        3.99232816696167,
+        3.8482789993286133,
+        3.942899227142334,
+        3.893601894378662,
+        3.8844542503356934,
+        4.02971076965332,
+        3.851468086242676,
+        4.060338497161865,
+        3.9119908809661865,
+        4.287752151489258,
+        4.191795349121094,
+        3.882951498031616,
+        3.714550018310547,
+        4.303031921386719,
+        4.081474304199219,
+        4.244274616241455,
+        3.9838271141052246,
+        3.966465711593628,
+        4.015554428100586,
+        3.7368316650390625,
+        4.032900810241699,
+        3.829380512237549,
+        4.046370506286621,
+        3.943946361541748,
+        3.98945689201355,
+        3.927220344543457,
+        3.9734270572662354,
+        4.044177055358887,
+        3.8985655307769775,
+        4.077480316162109,
+        3.9693150520324707,
+        3.787632465362549,
+        3.7594494819641113,
+        4.000375270843506,
+        3.9640064239501953,
+        3.8909759521484375,
+        3.850790023803711,
+        4.125975131988525,
+        3.7803969383239746,
+        3.7465341091156006,
+        4.195216178894043,
+        3.841724157333374,
+        4.22285270690918,
+        4.265176773071289,
+        3.778024196624756,
+        3.725446939468384,
+        4.087458610534668,
+        4.120079040527344,
+        3.912097215652466,
+        4.200753688812256,
+        3.994182586669922,
+        3.8501152992248535,
+        4.0868940353393555,
+        3.957892894744873,
+        3.990758180618286,
+        3.9712400436401367,
+        3.9374632835388184,
+        3.865813970565796,
+        3.747910737991333,
+        3.9502601623535156,
+        4.065150737762451,
+        3.7691380977630615,
+        3.750119686126709,
+        3.858621597290039,
+        3.8380439281463623,
+        3.94753098487854,
+        4.121711730957031
+    ]
+}
\ No newline at end of file
diff --git a/docs/examples/robust_paper/results/opt_markowitz.json b/docs/examples/robust_paper/results/opt_markowitz.json
new file mode 100644
index 00000000..a2fc1da5
--- /dev/null
+++ b/docs/examples/robust_paper/results/opt_markowitz.json
@@ -0,0 +1,2706 @@
+{
+    "monte_carlo_eif-one_step": [
+        [
+            0.023934517055749893,
+            0.10391602665185928,
+            0.030650828033685684,
+            0.20428776741027832,
+            0.09961473941802979,
+            0.0828445702791214,
+            -0.03396529704332352,
+            0.22358159720897675,
+            -0.08423313498497009,
+            0.09937536716461182,
+            0.04893643781542778,
+            -0.060195524245500565,
+            0.21584920585155487,
+            -0.05662914365530014,
+            -0.03566783666610718,
+            -0.05134405195713043,
+            0.021067213267087936,
+            0.10323268920183182,
+            -0.13589322566986084,
+            0.022852422669529915,
+            -0.08326634019613266,
+            0.10152234882116318,
+            0.027032099664211273,
+            0.08156543225049973,
+            0.05093131959438324
+        ],
+        [
+            0.012502651661634445,
+            0.09521563351154327,
+            0.03785618022084236,
+            0.22812537848949432,
+            0.04504485800862312,
+            0.0007587112486362457,
+            -0.017028439790010452,
+            0.2623814344406128,
+            -0.09301409125328064,
+            0.12414009124040604,
+            0.11770625412464142,
+            -0.08926991373300552,
+            0.23846431076526642,
+            -0.068234883248806,
+            -0.07055478543043137,
+            -0.0566805899143219,
+            0.005033699795603752,
+            0.06990224123001099,
+            -0.13647663593292236,
+            -0.006652794778347015,
+            -0.07479742914438248,
+            0.12306735664606094,
+            0.06291110813617706,
+            0.12362442910671234,
+            0.06597530841827393
+        ],
+        [
+            0.010236149653792381,
+            0.09706955403089523,
+            0.04039406403899193,
+            0.22339847683906555,
+            0.056239694356918335,
+            0.018663570284843445,
+            -0.02231811359524727,
+            0.24955910444259644,
+            -0.09165553748607635,
+            0.11526307463645935,
+            0.1028037965297699,
+            -0.08611875772476196,
+            0.23502478003501892,
+            -0.06234493479132652,
+            -0.06405985355377197,
+            -0.05581279844045639,
+            0.00724783493205905,
+            0.08133698999881744,
+            -0.13364359736442566,
+            0.00018800236284732819,
+            -0.07372213900089264,
+            0.12056759744882584,
+            0.05590231716632843,
+            0.11396871507167816,
+            0.06181197986006737
+        ],
+        [
+            0.007298532407730818,
+            0.09441237896680832,
+            0.04007191210985184,
+            0.23042479157447815,
+            0.038326069712638855,
+            -0.004947074688971043,
+            -0.015485145151615143,
+            0.263778954744339,
+            -0.09680283069610596,
+            0.12836259603500366,
+            0.12423913180828094,
+            -0.09300480782985687,
+            0.24021700024604797,
+            -0.06833546608686447,
+            -0.0717611014842987,
+            -0.06141665205359459,
+            0.0009848333429545164,
+            0.07088877260684967,
+            -0.13249287009239197,
+            -0.010305631905794144,
+            -0.07111578434705734,
+            0.12210114300251007,
+            0.06721726804971695,
+            0.13122792541980743,
+            0.06611599028110504
+        ],
+        [
+            0.021678635850548744,
+            0.11079815775156021,
+            0.03452928364276886,
+            0.2135300636291504,
+            0.06585895270109177,
+            0.024536699056625366,
+            -0.02983958087861538,
+            0.2577701210975647,
+            -0.09637752920389175,
+            0.1275022327899933,
+            0.09668156504631042,
+            -0.07667440176010132,
+            0.233979269862175,
+            -0.06856420636177063,
+            -0.05299955978989601,
+            -0.06300165504217148,
+            0.00759439030662179,
+            0.07559166103601456,
+            -0.14386272430419922,
+            0.007969856262207031,
+            -0.07759088277816772,
+            0.107962965965271,
+            0.04586704447865486,
+            0.11213669180870056,
+            0.06492302566766739
+        ],
+        [
+            0.018096990883350372,
+            0.08949816226959229,
+            0.051117122173309326,
+            0.21241357922554016,
+            0.06506651639938354,
+            0.036908894777297974,
+            -0.025557488203048706,
+            0.2365119308233261,
+            -0.08485127985477448,
+            0.10150469839572906,
+            0.09164004027843475,
+            -0.08919734507799149,
+            0.22899901866912842,
+            -0.05920884758234024,
+            -0.05642300844192505,
+            -0.044081613421440125,
+            0.015481491573154926,
+            0.0892670527100563,
+            -0.12614654004573822,
+            -0.0011294474825263023,
+            -0.07898702472448349,
+            0.12393060326576233,
+            0.043125953525304794,
+            0.10571420192718506,
+            0.05630623921751976
+        ],
+        [
+            0.014897256158292294,
+            0.10926703363656998,
+            0.03940379619598389,
+            0.23527416586875916,
+            0.06697485595941544,
+            0.05426144227385521,
+            -0.02820504829287529,
+            0.23645645380020142,
+            -0.08130344748497009,
+            0.0922422930598259,
+            0.08437874913215637,
+            -0.07604247331619263,
+            0.2409544438123703,
+            -0.047831300646066666,
+            -0.06795413792133331,
+            -0.05184769630432129,
+            0.030483610928058624,
+            0.09380677342414856,
+            -0.16704517602920532,
+            0.02559460885822773,
+            -0.09009218215942383,
+            0.13193285465240479,
+            0.019399572163820267,
+            0.07859279960393906,
+            0.056400686502456665
+        ],
+        [
+            0.009978750720620155,
+            0.09323801100254059,
+            0.04244571924209595,
+            0.230803444981575,
+            0.0433427095413208,
+            0.006634548306465149,
+            -0.01564936339855194,
+            0.2537459135055542,
+            -0.09054732322692871,
+            0.11741746217012405,
+            0.11652836203575134,
+            -0.09247290343046188,
+            0.2374374121427536,
+            -0.06475486606359482,
+            -0.07093308866024017,
+            -0.05413798615336418,
+            0.0058693718165159225,
+            0.07576984167098999,
+            -0.13230156898498535,
+            -0.009571695700287819,
+            -0.07298541814088821,
+            0.12445204704999924,
+            0.059866763651371,
+            0.12260042130947113,
+            0.06322336196899414
+        ],
+        [
+            0.04761169105768204,
+            0.08857715874910355,
+            0.05756258964538574,
+            0.19104395806789398,
+            0.13948071002960205,
+            0.16823413968086243,
+            -0.03166867420077324,
+            0.1774766594171524,
+            -0.0529337003827095,
+            0.06914474070072174,
+            0.014799803495407104,
+            -0.0902218371629715,
+            0.22184213995933533,
+            -0.09058848023414612,
+            -0.007650204002857208,
+            -0.001164466142654419,
+            0.06742551922798157,
+            0.13248400390148163,
+            -0.14450077712535858,
+            0.0030344086699187756,
+            -0.12330087274312973,
+            0.15176492929458618,
+            -0.05090641975402832,
+            0.05104805529117584,
+            0.011404909193515778
+        ],
+        [
+            0.012635942548513412,
+            0.10043657571077347,
+            0.03870992362499237,
+            0.23599380254745483,
+            0.04663138464093208,
+            0.012617727741599083,
+            -0.021365921944379807,
+            0.25729113817214966,
+            -0.09118969738483429,
+            0.1138194128870964,
+            0.11117957532405853,
+            -0.08939296007156372,
+            0.2425679862499237,
+            -0.06083076819777489,
+            -0.0743970274925232,
+            -0.055623967200517654,
+            0.010239520110189915,
+            0.07633360475301743,
+            -0.14755085110664368,
+            0.003314177505671978,
+            -0.07726237922906876,
+            0.12838630378246307,
+            0.05152657628059387,
+            0.11070942133665085,
+            0.06522060930728912
+        ],
+        [
+            0.024318290874361992,
+            0.1029079481959343,
+            0.03419695794582367,
+            0.2176571935415268,
+            0.07402241230010986,
+            0.04170048609375954,
+            -0.0301106758415699,
+            0.24907124042510986,
+            -0.08658751100301743,
+            0.11102960258722305,
+            0.08639150112867355,
+            -0.0772794559597969,
+            0.234671488404274,
+            -0.06508374959230423,
+            -0.054060570895671844,
+            -0.051320210099220276,
+            0.019145730882883072,
+            0.08289317041635513,
+            -0.14633993804454803,
+            0.011894061230123043,
+            -0.08683513104915619,
+            0.11749687045812607,
+            0.03695676103234291,
+            0.09418753534555435,
+            0.059076059609651566
+        ],
+        [
+            0.007820388302206993,
+            0.09374067187309265,
+            0.04168950021266937,
+            0.2326081395149231,
+            0.03986261785030365,
+            0.0022376030683517456,
+            -0.015517337247729301,
+            0.25859373807907104,
+            -0.0938112735748291,
+            0.12366423010826111,
+            0.11986199021339417,
+            -0.09307393431663513,
+            0.2393742948770523,
+            -0.06643065065145493,
+            -0.07249382883310318,
+            -0.058567117899656296,
+            0.0026491908356547356,
+            0.07623175531625748,
+            -0.13181787729263306,
+            -0.010138653218746185,
+            -0.07245369255542755,
+            0.12364424765110016,
+            0.06190395727753639,
+            0.12657888233661652,
+            0.06384314596652985
+        ],
+        [
+            0.0063347285613417625,
+            0.09513811767101288,
+            0.04003283008933067,
+            0.23203431069850922,
+            0.038947489112615585,
+            -0.0004764515906572342,
+            -0.016172096133232117,
+            0.25946566462516785,
+            -0.09788113087415695,
+            0.12373822182416916,
+            0.12089374661445618,
+            -0.09407573193311691,
+            0.2402348667383194,
+            -0.06427770107984543,
+            -0.0728355422616005,
+            -0.060897767543792725,
+            0.001239735633134842,
+            0.07568393647670746,
+            -0.13213467597961426,
+            -0.008348437957465649,
+            -0.0697246864438057,
+            0.12386325001716614,
+            0.06580543518066406,
+            0.12790082395076752,
+            0.06551109999418259
+        ],
+        [
+            0.007561175152659416,
+            0.09475784003734589,
+            0.03954215347766876,
+            0.23114162683486938,
+            0.040273092687129974,
+            -0.0010053794831037521,
+            -0.016357000917196274,
+            0.26149672269821167,
+            -0.09620064496994019,
+            0.12593014538288116,
+            0.12102128565311432,
+            -0.09422239661216736,
+            0.24030639231204987,
+            -0.06683987379074097,
+            -0.07247436046600342,
+            -0.05937030911445618,
+            0.0010505970567464828,
+            0.07424727082252502,
+            -0.13312898576259613,
+            -0.00950655434280634,
+            -0.07193635404109955,
+            0.12369774281978607,
+            0.06589265167713165,
+            0.12881341576576233,
+            0.06530974805355072
+        ],
+        [
+            0.006102749612182379,
+            0.09392181038856506,
+            0.03925464302301407,
+            0.22921203076839447,
+            0.04107716307044029,
+            -0.00044219568371772766,
+            -0.017350146546959877,
+            0.2636159062385559,
+            -0.10051006823778152,
+            0.13127416372299194,
+            0.12154733389616013,
+            -0.09541664272546768,
+            0.24087300896644592,
+            -0.06999107450246811,
+            -0.07143118232488632,
+            -0.061622731387615204,
+            -0.0001563606783747673,
+            0.0749051421880722,
+            -0.13050222396850586,
+            -0.011356392875313759,
+            -0.07042494416236877,
+            0.12199512124061584,
+            0.06803370267152786,
+            0.13136087357997894,
+            0.06603030115365982
+        ],
+        [
+            0.02534121833741665,
+            0.10589192807674408,
+            0.031725309789180756,
+            0.2145257592201233,
+            0.07749392092227936,
+            0.04634568840265274,
+            -0.028646372258663177,
+            0.2423926442861557,
+            -0.0791814774274826,
+            0.11555325984954834,
+            0.0853009819984436,
+            -0.05765724554657936,
+            0.2247491031885147,
+            -0.06530754268169403,
+            -0.04187784343957901,
+            -0.05623432993888855,
+            0.02223975770175457,
+            0.07253460586071014,
+            -0.1481981873512268,
+            0.008972021751105785,
+            -0.08278486877679825,
+            0.09948734194040298,
+            0.03375548496842384,
+            0.09491662681102753,
+            0.058662205934524536
+        ],
+        [
+            0.008189614862203598,
+            0.0940166637301445,
+            0.03892594203352928,
+            0.22884146869182587,
+            0.04161462560296059,
+            -0.002694191876798868,
+            -0.01641220785677433,
+            0.2633184492588043,
+            -0.09787638485431671,
+            0.12823067605495453,
+            0.12080862373113632,
+            -0.09393535554409027,
+            0.23934949934482574,
+            -0.0690569058060646,
+            -0.07218047231435776,
+            -0.058718759566545486,
+            1.147482544183731e-05,
+            0.07235768437385559,
+            -0.13136158883571625,
+            -0.01015026867389679,
+            -0.071063332259655,
+            0.12331968545913696,
+            0.06842158734798431,
+            0.12983429431915283,
+            0.06620923429727554
+        ],
+        [
+            0.013655225746333599,
+            0.10489026457071304,
+            0.042001038789749146,
+            0.23811402916908264,
+            0.0649639368057251,
+            0.05166982114315033,
+            -0.025143705308437347,
+            0.24318578839302063,
+            -0.08729298412799835,
+            0.10458840429782867,
+            0.09462489187717438,
+            -0.08297739923000336,
+            0.24110010266304016,
+            -0.060081660747528076,
+            -0.05926299840211868,
+            -0.05582968890666962,
+            0.02815956622362137,
+            0.0886867344379425,
+            -0.1514403522014618,
+            0.006431119982153177,
+            -0.08847449719905853,
+            0.12551642954349518,
+            0.020971238613128662,
+            0.09016742557287216,
+            0.05177728086709976
+        ],
+        [
+            0.009903005324304104,
+            0.09619412571191788,
+            0.04003133252263069,
+            0.2351914793252945,
+            0.04044502228498459,
+            0.001990698277950287,
+            -0.01653888449072838,
+            0.25910401344299316,
+            -0.09420982748270035,
+            0.1193353533744812,
+            0.11918065696954727,
+            -0.09193327277898788,
+            0.24063420295715332,
+            -0.06329669058322906,
+            -0.07256574183702469,
+            -0.05964917689561844,
+            0.005100538022816181,
+            0.07436913251876831,
+            -0.1377996951341629,
+            -0.004902851767838001,
+            -0.07246173173189163,
+            0.12357313930988312,
+            0.061431270092725754,
+            0.1229628399014473,
+            0.0639110654592514
+        ],
+        [
+            0.012090042233467102,
+            0.09909966588020325,
+            0.04000702127814293,
+            0.23837317526340485,
+            0.04840490221977234,
+            0.018290508538484573,
+            -0.020857520401477814,
+            0.2532919645309448,
+            -0.09154525399208069,
+            0.1090753972530365,
+            0.1074850857257843,
+            -0.09366843849420547,
+            0.24357149004936218,
+            -0.05829538404941559,
+            -0.07461004704236984,
+            -0.055252015590667725,
+            0.010377619415521622,
+            0.0828692764043808,
+            -0.14464066922664642,
+            0.0034373346716165543,
+            -0.07666672021150589,
+            0.12840139865875244,
+            0.050308987498283386,
+            0.1087193414568901,
+            0.06173284351825714
+        ],
+        [
+            0.007889281958341599,
+            0.1084492951631546,
+            0.023524709045886993,
+            0.23066243529319763,
+            0.045864999294281006,
+            0.014089595526456833,
+            -0.019862279295921326,
+            0.2684328258037567,
+            -0.09628941118717194,
+            0.14167895913124084,
+            0.11733396351337433,
+            -0.07770466804504395,
+            0.24083226919174194,
+            -0.07444775104522705,
+            -0.06289298832416534,
+            -0.0676550641655922,
+            0.008699526078999043,
+            0.06624114513397217,
+            -0.15140970051288605,
+            -0.000893683172762394,
+            -0.07515809684991837,
+            0.11165918409824371,
+            0.05448899418115616,
+            0.11888100951910019,
+            0.06758541613817215
+        ],
+        [
+            0.005966433323919773,
+            0.09526877105236053,
+            0.038645338267087936,
+            0.23236659169197083,
+            0.03852282091975212,
+            -0.0026236847043037415,
+            -0.015849003568291664,
+            0.2638472318649292,
+            -0.09909731149673462,
+            0.13014695048332214,
+            0.12367697060108185,
+            -0.09428907185792923,
+            0.24052849411964417,
+            -0.06874601542949677,
+            -0.07206269353628159,
+            -0.06238774210214615,
+            -0.0006746174767613411,
+            0.07238075137138367,
+            -0.13246768712997437,
+            -0.010521300137043,
+            -0.07068128883838654,
+            0.12160728871822357,
+            0.06791671365499496,
+            0.1320120394229889,
+            0.06651407480239868
+        ],
+        [
+            0.008254551328718662,
+            0.09350193291902542,
+            0.04036496952176094,
+            0.2271432876586914,
+            0.04079800471663475,
+            -0.00810635183006525,
+            -0.015417719259858131,
+            0.2662808299064636,
+            -0.10001960396766663,
+            0.13138078153133392,
+            0.12319518625736237,
+            -0.09320032596588135,
+            0.23829907178878784,
+            -0.07010611891746521,
+            -0.07158311456441879,
+            -0.06136981025338173,
+            -0.0028776628896594048,
+            0.06980860233306885,
+            -0.13050061464309692,
+            -0.01114844810217619,
+            -0.07108499109745026,
+            0.12129444628953934,
+            0.0723397433757782,
+            0.13471777737140656,
+            0.06803562492132187
+        ],
+        [
+            0.011057076044380665,
+            0.09034748375415802,
+            0.043091967701911926,
+            0.22407276928424835,
+            0.04739409685134888,
+            0.006746720056980848,
+            -0.017474744468927383,
+            0.25325146317481995,
+            -0.09446538984775543,
+            0.11957645416259766,
+            0.11334793269634247,
+            -0.09537286311388016,
+            0.23646871745586395,
+            -0.06592965871095657,
+            -0.06687437742948532,
+            -0.05516640469431877,
+            0.0024597635492682457,
+            0.07728829979896545,
+            -0.1286628395318985,
+            -0.009095937013626099,
+            -0.07172451913356781,
+            0.12482696026563644,
+            0.06403525918722153,
+            0.12632180750370026,
+            0.0644800141453743
+        ],
+        [
+            0.00641236174851656,
+            0.09550297260284424,
+            0.040032029151916504,
+            0.23195162415504456,
+            0.04292680695652962,
+            0.012307579629123211,
+            -0.018571674823760986,
+            0.2536364197731018,
+            -0.09573128074407578,
+            0.1228683665394783,
+            0.11361898481845856,
+            -0.09496911615133286,
+            0.2400011569261551,
+            -0.06350355595350266,
+            -0.07203974574804306,
+            -0.05853495001792908,
+            0.004124634899199009,
+            0.08365938067436218,
+            -0.13342060148715973,
+            -0.00675103347748518,
+            -0.07232445478439331,
+            0.1246064081788063,
+            0.05960570275783539,
+            0.12211650609970093,
+            0.062475450336933136
+        ],
+        [
+            0.008172435685992241,
+            0.09633325785398483,
+            0.037667058408260345,
+            0.23481282591819763,
+            0.03870054706931114,
+            -0.0003484319895505905,
+            -0.01595776341855526,
+            0.2642143666744232,
+            -0.09707459807395935,
+            0.12754850089550018,
+            0.12254014611244202,
+            -0.0944717675447464,
+            0.2423664629459381,
+            -0.06829585880041122,
+            -0.07438356429338455,
+            -0.05969806760549545,
+            0.002534611616283655,
+            0.07238231599330902,
+            -0.13732880353927612,
+            -0.0088485823944211,
+            -0.07356685400009155,
+            0.12413923442363739,
+            0.06482681632041931,
+            0.12774434685707092,
+            0.06599131226539612
+        ],
+        [
+            0.013332139700651169,
+            0.0980292558670044,
+            0.04146825894713402,
+            0.22309745848178864,
+            0.05491705983877182,
+            0.010760316625237465,
+            -0.02173374779522419,
+            0.2536962628364563,
+            -0.08803310245275497,
+            0.11404439806938171,
+            0.10965797305107117,
+            -0.0795711949467659,
+            0.2348511964082718,
+            -0.06286618858575821,
+            -0.06381288915872574,
+            -0.05769168585538864,
+            0.010134458541870117,
+            0.07365784794092178,
+            -0.13904497027397156,
+            0.0020107387099415064,
+            -0.07701532542705536,
+            0.12053219974040985,
+            0.05407930538058281,
+            0.11201081424951553,
+            0.0634893923997879
+        ],
+        [
+            0.008902546018362045,
+            0.0931653380393982,
+            0.04038050025701523,
+            0.2288747876882553,
+            0.03995969146490097,
+            -0.00455824751406908,
+            -0.014882839284837246,
+            0.26275256276130676,
+            -0.09683482348918915,
+            0.12766960263252258,
+            0.12277264147996902,
+            -0.0936017706990242,
+            0.23738381266593933,
+            -0.06826993823051453,
+            -0.07098398357629776,
+            -0.05888396501541138,
+            0.0003056926652789116,
+            0.07075553387403488,
+            -0.1290484517812729,
+            -0.012701310217380524,
+            -0.07014504820108414,
+            0.12162313610315323,
+            0.06829500198364258,
+            0.13201230764389038,
+            0.06505724042654037
+        ],
+        [
+            0.008546768687665462,
+            0.09682165831327438,
+            0.039112258702516556,
+            0.23139046132564545,
+            0.04051965847611427,
+            -0.0003757793456315994,
+            -0.017023183405399323,
+            0.26313549280166626,
+            -0.0972883328795433,
+            0.12643426656723022,
+            0.1200847327709198,
+            -0.09377896785736084,
+            0.24124394357204437,
+            -0.06635942310094833,
+            -0.07379212230443954,
+            -0.0599169060587883,
+            0.0026417002081871033,
+            0.07220453023910522,
+            -0.13643521070480347,
+            -0.006297340616583824,
+            -0.07246729731559753,
+            0.12395960837602615,
+            0.0643758773803711,
+            0.12639419734477997,
+            0.06686936318874359
+        ],
+        [
+            0.012483764439821243,
+            0.10014830529689789,
+            0.03836658596992493,
+            0.23125438392162323,
+            0.05747928097844124,
+            0.03750649094581604,
+            -0.024293415248394012,
+            0.24015097320079803,
+            -0.0863446444272995,
+            0.10244463384151459,
+            0.09444975852966309,
+            -0.08694438636302948,
+            0.2360498011112213,
+            -0.05400779843330383,
+            -0.06824710965156555,
+            -0.050927940756082535,
+            0.015168417245149612,
+            0.0937185063958168,
+            -0.14165763556957245,
+            0.007904672995209694,
+            -0.07916979491710663,
+            0.12562990188598633,
+            0.04128171503543854,
+            0.09955310821533203,
+            0.05800241231918335
+        ],
+        [
+            0.010672241449356079,
+            0.10042688995599747,
+            0.03532062843441963,
+            0.23285438120365143,
+            0.048513539135456085,
+            0.014243748039007187,
+            -0.021508844569325447,
+            0.25831860303878784,
+            -0.09530001133680344,
+            0.12223297357559204,
+            0.1084645614027977,
+            -0.08793517202138901,
+            0.24288392066955566,
+            -0.06360001862049103,
+            -0.07199156284332275,
+            -0.057295605540275574,
+            0.008369902148842812,
+            0.07599424570798874,
+            -0.1467665433883667,
+            0.0035940539091825485,
+            -0.07688283920288086,
+            0.12395236641168594,
+            0.05484294146299362,
+            0.11450596153736115,
+            0.0660897046327591
+        ],
+        [
+            0.006610799115151167,
+            0.09570211172103882,
+            0.04074234887957573,
+            0.23333221673965454,
+            0.03782333806157112,
+            -0.0009430162608623505,
+            -0.017345264554023743,
+            0.26057329773902893,
+            -0.09702428430318832,
+            0.12369001656770706,
+            0.12212461978197098,
+            -0.09546104073524475,
+            0.24091655015945435,
+            -0.06473837047815323,
+            -0.07370495796203613,
+            -0.06071233004331589,
+            0.0015191049315035343,
+            0.07558870315551758,
+            -0.13219985365867615,
+            -0.008669300936162472,
+            -0.07061145454645157,
+            0.12361899018287659,
+            0.06565509736537933,
+            0.12839002907276154,
+            0.06512264162302017
+        ],
+        [
+            0.007719922345131636,
+            0.09969597309827805,
+            0.04198383912444115,
+            0.2304300218820572,
+            0.046428777277469635,
+            0.01377137377858162,
+            -0.020777281373739243,
+            0.25042155385017395,
+            -0.09181752055883408,
+            0.11320140212774277,
+            0.11262507736682892,
+            -0.09181247651576996,
+            0.23791757225990295,
+            -0.059734903275966644,
+            -0.0714104101061821,
+            -0.057532258331775665,
+            0.00938576553016901,
+            0.0835447832942009,
+            -0.13516952097415924,
+            -0.002222158946096897,
+            -0.07331611216068268,
+            0.12352420389652252,
+            0.055758893489837646,
+            0.11583076417446136,
+            0.06155276671051979
+        ],
+        [
+            0.012448607943952084,
+            0.09630089998245239,
+            0.040464580059051514,
+            0.22998683154582977,
+            0.045879341661930084,
+            0.009401664137840271,
+            -0.01888025924563408,
+            0.2536448538303375,
+            -0.08877117931842804,
+            0.11193642020225525,
+            0.11156237125396729,
+            -0.09018561244010925,
+            0.2401447594165802,
+            -0.0586053840816021,
+            -0.0729600265622139,
+            -0.05325120687484741,
+            0.009138250723481178,
+            0.07714705914258957,
+            -0.14055578410625458,
+            0.002635459415614605,
+            -0.07551636546850204,
+            0.1255001276731491,
+            0.056311048567295074,
+            0.11276242882013321,
+            0.06346111744642258
+        ],
+        [
+            0.007828177884221077,
+            0.09693843871355057,
+            0.038289062678813934,
+            0.23165085911750793,
+            0.03860461339354515,
+            -0.004619552753865719,
+            -0.017554400488734245,
+            0.26471850275993347,
+            -0.09725013375282288,
+            0.12723979353904724,
+            0.12373974174261093,
+            -0.09230276197195053,
+            0.24162299931049347,
+            -0.06638731062412262,
+            -0.07465654611587524,
+            -0.06063244491815567,
+            0.0017184701282531023,
+            0.07065289467573166,
+            -0.13642802834510803,
+            -0.0069651417434215546,
+            -0.07157815247774124,
+            0.12327484041452408,
+            0.06656605750322342,
+            0.12717849016189575,
+            0.06835151463747025
+        ],
+        [
+            0.0041258931159973145,
+            0.10111686587333679,
+            0.041688840836286545,
+            0.2436641901731491,
+            0.04277666658163071,
+            0.026303987950086594,
+            -0.020180722698569298,
+            0.24617597460746765,
+            -0.0931878387928009,
+            0.11017077416181564,
+            0.1102420911192894,
+            -0.0972258672118187,
+            0.2480282336473465,
+            -0.056106291711330414,
+            -0.07745900750160217,
+            -0.059080351144075394,
+            0.01212766207754612,
+            0.09219573438167572,
+            -0.14305871725082397,
+            0.0005274522118270397,
+            -0.07640539109706879,
+            0.13114559650421143,
+            0.045731328427791595,
+            0.10732011497020721,
+            0.05936285853385925
+        ],
+        [
+            0.007126253563910723,
+            0.09389611333608627,
+            0.04052164405584335,
+            0.22889778017997742,
+            0.040657855570316315,
+            -0.000960296019911766,
+            -0.0161849707365036,
+            0.2610943019390106,
+            -0.09821522235870361,
+            0.12825186550617218,
+            0.12105259299278259,
+            -0.09572925418615341,
+            0.23937980830669403,
+            -0.06735660880804062,
+            -0.07079886645078659,
+            -0.059987444430589676,
+            -0.00032823067158460617,
+            0.07434052228927612,
+            -0.12911199033260345,
+            -0.011382129043340683,
+            -0.0708538293838501,
+            0.12178989499807358,
+            0.06773652136325836,
+            0.13164536654949188,
+            0.0645182654261589
+        ],
+        [
+            0.007346010766923428,
+            0.09658447653055191,
+            0.03878764063119888,
+            0.23160697519779205,
+            0.03681807219982147,
+            -0.007632646709680557,
+            -0.017841476947069168,
+            0.2670601010322571,
+            -0.09942599385976791,
+            0.12921178340911865,
+            0.12539906799793243,
+            -0.0944356620311737,
+            0.24203366041183472,
+            -0.06746602803468704,
+            -0.07505284994840622,
+            -0.061426255851984024,
+            0.000142175005748868,
+            0.07044414430856705,
+            -0.1348210722208023,
+            -0.008785884827375412,
+            -0.07080017030239105,
+            0.12324642390012741,
+            0.06979065388441086,
+            0.13038647174835205,
+            0.06883041560649872
+        ],
+        [
+            0.006104824133217335,
+            0.09965795278549194,
+            0.03911568224430084,
+            0.23594702780246735,
+            0.04621906578540802,
+            0.020642610266804695,
+            -0.02097337506711483,
+            0.2481960654258728,
+            -0.0956089049577713,
+            0.11203493177890778,
+            0.10691890120506287,
+            -0.09274102002382278,
+            0.23984394967556,
+            -0.056670382618904114,
+            -0.06938507407903671,
+            -0.05942192301154137,
+            0.007782148662954569,
+            0.0890478789806366,
+            -0.13698697090148926,
+            0.0012189233675599098,
+            -0.07242319732904434,
+            0.12297601252794266,
+            0.05421818792819977,
+            0.11307692527770996,
+            0.06120976805686951
+        ],
+        [
+            0.010002466849982738,
+            0.09845338016748428,
+            0.04283113777637482,
+            0.2347639948129654,
+            0.0453454852104187,
+            0.01278800331056118,
+            -0.018659045919775963,
+            0.25234976410865784,
+            -0.09211025387048721,
+            0.11107879132032394,
+            0.11260388791561127,
+            -0.092500239610672,
+            0.24059753119945526,
+            -0.058504343032836914,
+            -0.07299439609050751,
+            -0.05541451647877693,
+            0.007680961862206459,
+            0.08081593364477158,
+            -0.1390521377325058,
+            -0.002103577833622694,
+            -0.07607915997505188,
+            0.12690967321395874,
+            0.054532263427972794,
+            0.11393450200557709,
+            0.06272989511489868
+        ],
+        [
+            0.007998604327440262,
+            0.09523564577102661,
+            0.039373647421598434,
+            0.22722962498664856,
+            0.03729867935180664,
+            -0.011738328263163567,
+            -0.014956716448068619,
+            0.26542186737060547,
+            -0.09697823226451874,
+            0.12940792739391327,
+            0.12733878195285797,
+            -0.09140793979167938,
+            0.23892873525619507,
+            -0.06776710599660873,
+            -0.07151072472333908,
+            -0.0613940954208374,
+            -0.0008923709392547607,
+            0.06731651723384857,
+            -0.130777508020401,
+            -0.010649292729794979,
+            -0.07030016928911209,
+            0.12062085419893265,
+            0.06969790905714035,
+            0.133805513381958,
+            0.06869826465845108
+        ],
+        [
+            0.009190356358885765,
+            0.09641670435667038,
+            0.03927445411682129,
+            0.2311922013759613,
+            0.04320488125085831,
+            0.003770173527300358,
+            -0.0183156356215477,
+            0.26157456636428833,
+            -0.09755147993564606,
+            0.12583567202091217,
+            0.11715894192457199,
+            -0.09382915496826172,
+            0.24196912348270416,
+            -0.06635552644729614,
+            -0.07203560322523117,
+            -0.05913115665316582,
+            0.003139580599963665,
+            0.0743534117937088,
+            -0.13620638847351074,
+            -0.00651737954467535,
+            -0.07431814819574356,
+            0.123636394739151,
+            0.06294003874063492,
+            0.12484483420848846,
+            0.06575913727283478
+        ],
+        [
+            0.012941383756697178,
+            0.09480088204145432,
+            0.04162988066673279,
+            0.22862480580806732,
+            0.04627488926053047,
+            0.0037027383223176003,
+            -0.01782807894051075,
+            0.26007285714149475,
+            -0.09309985488653183,
+            0.11929299682378769,
+            0.1163625717163086,
+            -0.09078936278820038,
+            0.2381262332201004,
+            -0.06547591835260391,
+            -0.07078029215335846,
+            -0.05609112232923508,
+            0.005956794135272503,
+            0.07274916768074036,
+            -0.13721078634262085,
+            -0.006076411809772253,
+            -0.07508620619773865,
+            0.12409797310829163,
+            0.059934843331575394,
+            0.12216239422559738,
+            0.065707728266716
+        ],
+        [
+            0.0076819853857159615,
+            0.09505812078714371,
+            0.03911247476935387,
+            0.23105557262897491,
+            0.039936672896146774,
+            -0.002010549884289503,
+            -0.016739429906010628,
+            0.26174136996269226,
+            -0.09647051244974136,
+            0.1263190358877182,
+            0.12070579081773758,
+            -0.09259586781263351,
+            0.2397128939628601,
+            -0.06658002734184265,
+            -0.07312659919261932,
+            -0.05985947325825691,
+            0.0005833066534250975,
+            0.0730193704366684,
+            -0.13302107155323029,
+            -0.00803760439157486,
+            -0.0711124986410141,
+            0.12265264242887497,
+            0.06702753156423569,
+            0.12844176590442657,
+            0.06650509685277939
+        ],
+        [
+            0.007803740445524454,
+            0.09611137211322784,
+            0.03988335654139519,
+            0.23100964725017548,
+            0.0384150929749012,
+            -0.004413796588778496,
+            -0.01671358197927475,
+            0.26301252841949463,
+            -0.09643732011318207,
+            0.12667535245418549,
+            0.12332363426685333,
+            -0.0927276611328125,
+            0.24011638760566711,
+            -0.0664740800857544,
+            -0.07351554930210114,
+            -0.06054219976067543,
+            0.0018564499914646149,
+            0.07175689935684204,
+            -0.13394278287887573,
+            -0.008683168329298496,
+            -0.07154976576566696,
+            0.12243223935365677,
+            0.06653573364019394,
+            0.12925148010253906,
+            0.06681594252586365
+        ],
+        [
+            0.017906850203871727,
+            0.10576031357049942,
+            0.035308562219142914,
+            0.22848553955554962,
+            0.06076333299279213,
+            0.02661137655377388,
+            -0.02554590255022049,
+            0.2513920068740845,
+            -0.08846081793308258,
+            0.10994626581668854,
+            0.09714669734239578,
+            -0.07817395776510239,
+            0.2385827898979187,
+            -0.057811543345451355,
+            -0.06649363040924072,
+            -0.05340861529111862,
+            0.013935573399066925,
+            0.07664170116186142,
+            -0.15640555322170258,
+            0.015285572037100792,
+            -0.08153805881738663,
+            0.12226606905460358,
+            0.041390061378479004,
+            0.09904066473245621,
+            0.06737465411424637
+        ],
+        [
+            0.0075489371083676815,
+            0.09674138575792313,
+            0.04089305177330971,
+            0.23485839366912842,
+            0.04248146712779999,
+            0.008113322779536247,
+            -0.015093985013663769,
+            0.2554556131362915,
+            -0.09388802945613861,
+            0.11923404037952423,
+            0.11811036616563797,
+            -0.0931176096200943,
+            0.23941880464553833,
+            -0.06334326416254044,
+            -0.07160738855600357,
+            -0.05845127999782562,
+            0.007632527034729719,
+            0.07696965336799622,
+            -0.13833022117614746,
+            -0.008012132719159126,
+            -0.07474919408559799,
+            0.1259380728006363,
+            0.0573120154440403,
+            0.12293829768896103,
+            0.06294722855091095
+        ],
+        [
+            0.008459274657070637,
+            0.09524877369403839,
+            0.03858782723546028,
+            0.22838981449604034,
+            0.04292551800608635,
+            0.0016848740633577108,
+            -0.01814219355583191,
+            0.2610012888908386,
+            -0.09667479246854782,
+            0.12624233961105347,
+            0.11797045916318893,
+            -0.09199938923120499,
+            0.23880772292613983,
+            -0.06722323596477509,
+            -0.07093406468629837,
+            -0.05941309407353401,
+            0.002345507498830557,
+            0.07393968850374222,
+            -0.13245172798633575,
+            -0.007279702462255955,
+            -0.07126683741807938,
+            0.12211195379495621,
+            0.06544676423072815,
+            0.12637601792812347,
+            0.06584710627794266
+        ],
+        [
+            0.007317517884075642,
+            0.09467779844999313,
+            0.038308363407850266,
+            0.22996187210083008,
+            0.04079073667526245,
+            -0.0015246253460645676,
+            -0.016889911144971848,
+            0.26296284794807434,
+            -0.09769292175769806,
+            0.12918376922607422,
+            0.11979920417070389,
+            -0.09306421130895615,
+            0.24035239219665527,
+            -0.06808505952358246,
+            -0.07305863499641418,
+            -0.060226380825042725,
+            -3.372738137841225e-05,
+            0.07289116829633713,
+            -0.13245530426502228,
+            -0.008917631581425667,
+            -0.07078266143798828,
+            0.12266561388969421,
+            0.0681220293045044,
+            0.12897810339927673,
+            0.0667196661233902
+        ],
+        [
+            0.015245865099132061,
+            0.10094515979290009,
+            0.04417067766189575,
+            0.23503555357456207,
+            0.053309470415115356,
+            0.029412511736154556,
+            -0.021813832223415375,
+            0.24310822784900665,
+            -0.08321934193372726,
+            0.09387160837650299,
+            0.10157477855682373,
+            -0.08785809576511383,
+            0.23944664001464844,
+            -0.04803742468357086,
+            -0.07624570280313492,
+            -0.048748429864645004,
+            0.01883903332054615,
+            0.08553953468799591,
+            -0.14834387600421906,
+            0.011906376108527184,
+            -0.08114904910326004,
+            0.13280296325683594,
+            0.03676782548427582,
+            0.09325306862592697,
+            0.06018640846014023
+        ]
+    ],
+    "plug-in-mle-from-model": [
+        [
+            0.02504074014723301,
+            0.11208155751228333,
+            0.04500477388501167,
+            0.22421085834503174,
+            0.07029399275779724,
+            0.05685338005423546,
+            -0.03214738145470619,
+            0.22596144676208496,
+            -0.06473396718502045,
+            0.08683893084526062,
+            0.09379305690526962,
+            -0.05932977423071861,
+            0.22646310925483704,
+            -0.05335167422890663,
+            -0.040553588420152664,
+            -0.051937535405159,
+            0.04780198633670807,
+            0.07714685052633286,
+            -0.16326633095741272,
+            0.014078385196626186,
+            -0.08709699660539627,
+            0.10887578874826431,
+            0.003299052594229579,
+            0.08129291236400604,
+            0.053380466997623444
+        ],
+        [
+            0.007244753185659647,
+            0.10109920799732208,
+            0.043792691081762314,
+            0.2427339404821396,
+            0.04078985005617142,
+            0.023706931620836258,
+            -0.022087084129452705,
+            0.2428499311208725,
+            -0.08911622315645218,
+            0.10524488240480423,
+            0.11195557564496994,
+            -0.09180672466754913,
+            0.2441134750843048,
+            -0.052781783044338226,
+            -0.07432284206151962,
+            -0.05917660892009735,
+            0.013062574900686741,
+            0.0900549590587616,
+            -0.14169052243232727,
+            9.109768870985135e-05,
+            -0.07310055941343307,
+            0.125862717628479,
+            0.044194385409355164,
+            0.106509268283844,
+            0.060776010155677795
+        ],
+        [
+            0.0024599963799118996,
+            0.10762026160955429,
+            0.03185362368822098,
+            0.2458258420228958,
+            0.05362491309642792,
+            0.05684632062911987,
+            -0.029366198927164078,
+            0.23028774559497833,
+            -0.09487929940223694,
+            0.10049157589673996,
+            0.08685491234064102,
+            -0.09422905743122101,
+            0.24277500808238983,
+            -0.04835144057869911,
+            -0.07058725506067276,
+            -0.05996747687458992,
+            0.014710195362567902,
+            0.11447134613990784,
+            -0.13794924318790436,
+            0.012800930067896843,
+            -0.0729358047246933,
+            0.12246926873922348,
+            0.03883059695363045,
+            0.09368283301591873,
+            0.05266043543815613
+        ],
+        [
+            0.007506850175559521,
+            0.09576302766799927,
+            0.03818385675549507,
+            0.2359219193458557,
+            0.0432635061442852,
+            0.012301010079681873,
+            -0.01558290608227253,
+            0.2557198405265808,
+            -0.09502410143613815,
+            0.12094639986753464,
+            0.11167358607053757,
+            -0.09319347143173218,
+            0.2425849884748459,
+            -0.0635962039232254,
+            -0.07351148873567581,
+            -0.059006500989198685,
+            0.0034021707251667976,
+            0.08066947013139725,
+            -0.13623455166816711,
+            -0.004350820556282997,
+            -0.07393238693475723,
+            0.1257583200931549,
+            0.058679718524217606,
+            0.12062034010887146,
+            0.06143737956881523
+        ],
+        [
+            0.023687105625867844,
+            0.09291765093803406,
+            0.030056258663535118,
+            0.2026967704296112,
+            0.08718931674957275,
+            0.052477773278951645,
+            -0.026270097121596336,
+            0.24463409185409546,
+            -0.07736366242170334,
+            0.13136884570121765,
+            0.08716133236885071,
+            -0.053832296282052994,
+            0.22145874798297882,
+            -0.07923295348882675,
+            -0.030200088396668434,
+            -0.05382630601525307,
+            0.014926251024007797,
+            0.06203952431678772,
+            -0.1362985372543335,
+            -0.001363255549222231,
+            -0.08737115561962128,
+            0.0890607163310051,
+            0.034429244697093964,
+            0.10769951343536377,
+            0.06395529210567474
+        ],
+        [
+            0.007209716830402613,
+            0.09809830039739609,
+            0.027083933353424072,
+            0.22296792268753052,
+            0.050251103937625885,
+            -0.018981074914336205,
+            -0.0191304050385952,
+            0.27593356370925903,
+            -0.10548021644353867,
+            0.14558672904968262,
+            0.1163817048072815,
+            -0.08035112917423248,
+            0.2313404381275177,
+            -0.07692170143127441,
+            -0.059411995112895966,
+            -0.07133190333843231,
+            -0.010104774497449398,
+            0.06112731620669365,
+            -0.1282939314842224,
+            -0.009314659982919693,
+            -0.0637008473277092,
+            0.10337880998849869,
+            0.08602390438318253,
+            0.14429859817028046,
+            0.07334057986736298
+        ],
+        [
+            0.014460591599345207,
+            0.1147109642624855,
+            0.03275183588266373,
+            0.23013466596603394,
+            0.08562345057725906,
+            0.10181892663240433,
+            -0.03926638886332512,
+            0.21012087166309357,
+            -0.07945065945386887,
+            0.08166471123695374,
+            0.04983557388186455,
+            -0.07043946534395218,
+            0.23405279219150543,
+            -0.040355268865823746,
+            -0.051936447620391846,
+            -0.051485031843185425,
+            0.0365547277033329,
+            0.12029023468494415,
+            -0.15602949261665344,
+            0.03859652206301689,
+            -0.08437366038560867,
+            0.11656869202852249,
+            0.003861003555357456,
+            0.0578363761305809,
+            0.04445447027683258
+        ],
+        [
+            0.01680327020585537,
+            0.10506454855203629,
+            0.03721469268202782,
+            0.22718632221221924,
+            0.06133616343140602,
+            0.028730124235153198,
+            -0.025723641738295555,
+            0.25191134214401245,
+            -0.08910637348890305,
+            0.11236639320850372,
+            0.09779765456914902,
+            -0.08140432834625244,
+            0.238631933927536,
+            -0.06108216941356659,
+            -0.06496279686689377,
+            -0.054276544600725174,
+            0.01658918522298336,
+            0.07979036122560501,
+            -0.15438580513000488,
+            0.012069741263985634,
+            -0.08419262617826462,
+            0.12371719628572464,
+            0.040367741137742996,
+            0.10110946744680405,
+            0.0644480511546135
+        ],
+        [
+            -0.00494646281003952,
+            0.1039045974612236,
+            0.029971592128276825,
+            0.19273176789283752,
+            0.019544774666428566,
+            -0.0702853575348854,
+            -0.024613335728645325,
+            0.2883526384830475,
+            -0.12280962616205215,
+            0.16456373035907745,
+            0.14753246307373047,
+            -0.07008574157953262,
+            0.21835778653621674,
+            -0.06769543886184692,
+            -0.05755145475268364,
+            -0.0896102711558342,
+            -0.03533397987484932,
+            0.038879431784152985,
+            -0.08871965110301971,
+            -0.004388852976262569,
+            -0.034325771033763885,
+            0.0712752565741539,
+            0.1285107433795929,
+            0.17252038419246674,
+            0.09422075748443604
+        ],
+        [
+            0.0121358847245574,
+            0.10533779114484787,
+            0.037964895367622375,
+            0.24242617189884186,
+            0.053263917565345764,
+            0.04137387126684189,
+            -0.02655487321317196,
+            0.24172118306159973,
+            -0.08549529314041138,
+            0.09833618253469467,
+            0.09843994677066803,
+            -0.08963484317064285,
+            0.24510197341442108,
+            -0.052334267646074295,
+            -0.07429076731204987,
+            -0.052865419536828995,
+            0.02170743979513645,
+            0.09375189989805222,
+            -0.15429292619228363,
+            0.011436223052442074,
+            -0.08090028911828995,
+            0.13214783370494843,
+            0.03382067382335663,
+            0.08854100853204727,
+            0.05886185169219971
+        ],
+        [
+            0.013457363471388817,
+            0.10394460707902908,
+            0.04660739004611969,
+            0.23767617344856262,
+            0.05659379065036774,
+            0.05237022042274475,
+            -0.02447238564491272,
+            0.2171010971069336,
+            -0.07169211655855179,
+            0.07943998277187347,
+            0.09674621373414993,
+            -0.07260105013847351,
+            0.23225101828575134,
+            -0.039919737726449966,
+            -0.058839038014411926,
+            -0.050175510346889496,
+            0.03385259583592415,
+            0.089564748108387,
+            -0.15333291888237,
+            0.01334398053586483,
+            -0.07516029477119446,
+            0.11835228651762009,
+            0.013527683913707733,
+            0.08515550196170807,
+            0.05620848014950752
+        ],
+        [
+            0.016244111582636833,
+            0.0978177934885025,
+            0.044188063591718674,
+            0.23741234838962555,
+            0.044758424162864685,
+            0.01621367409825325,
+            -0.02183314599096775,
+            0.2512064576148987,
+            -0.08728190511465073,
+            0.10573741793632507,
+            0.11179471760988235,
+            -0.09633554518222809,
+            0.2431887686252594,
+            -0.0563637912273407,
+            -0.07561194896697998,
+            -0.05301317572593689,
+            0.01390962116420269,
+            0.08194244652986526,
+            -0.1413017064332962,
+            -0.0007866209489293396,
+            -0.07495678961277008,
+            0.13351322710514069,
+            0.044871535152196884,
+            0.10659576952457428,
+            0.058090291917324066
+        ],
+        [
+            0.007366342470049858,
+            0.09598720073699951,
+            0.0407366082072258,
+            0.23485153913497925,
+            0.04304610192775726,
+            0.013316074386239052,
+            -0.01799600012600422,
+            0.2544057369232178,
+            -0.09443028271198273,
+            0.12043716758489609,
+            0.11440311372280121,
+            -0.09591865539550781,
+            0.24131536483764648,
+            -0.0643668845295906,
+            -0.07210036367177963,
+            -0.0583217553794384,
+            0.006158857140690088,
+            0.08316715061664581,
+            -0.13461890816688538,
+            -0.007589059416204691,
+            -0.07463955134153366,
+            0.12589047849178314,
+            0.05722374841570854,
+            0.12129784375429153,
+            0.060378145426511765
+        ],
+        [
+            0.0049713728949427605,
+            0.09772723913192749,
+            0.03978579118847847,
+            0.2356628030538559,
+            0.042374830693006516,
+            0.01215779222548008,
+            -0.018757624551653862,
+            0.25378891825675964,
+            -0.09659226983785629,
+            0.11831757426261902,
+            0.11334341764450073,
+            -0.09277421981096268,
+            0.2418847531080246,
+            -0.060864612460136414,
+            -0.07224464416503906,
+            -0.06148652732372284,
+            0.004844283685088158,
+            0.08399823307991028,
+            -0.13449853658676147,
+            -0.0032070099841803312,
+            -0.07174735516309738,
+            0.12321696430444717,
+            0.05894231051206589,
+            0.11977966874837875,
+            0.06137692183256149
+        ],
+        [
+            0.008243325166404247,
+            0.09842584282159805,
+            0.04191793501377106,
+            0.23778554797172546,
+            0.04548691585659981,
+            0.02269810065627098,
+            -0.01960376463830471,
+            0.24673821032047272,
+            -0.0913882926106453,
+            0.10857600718736649,
+            0.10688602179288864,
+            -0.09490268677473068,
+            0.24238242208957672,
+            -0.056810930371284485,
+            -0.07310296595096588,
+            -0.055613212287425995,
+            0.01159198023378849,
+            0.08972065150737762,
+            -0.13881579041481018,
+            0.00011234640260227025,
+            -0.0758453905582428,
+            0.12906914949417114,
+            0.04884544014930725,
+            0.11014682799577713,
+            0.05745620280504227
+        ],
+        [
+            0.028853273019194603,
+            0.09632012993097305,
+            0.050376374274492264,
+            0.19287686049938202,
+            0.09054568409919739,
+            0.06868252158164978,
+            -0.03663275018334389,
+            0.20270377397537231,
+            -0.06742607802152634,
+            0.0839870423078537,
+            0.0675101950764656,
+            -0.05894673988223076,
+            0.21284180879592896,
+            -0.05177157372236252,
+            -0.023607438430190086,
+            -0.04237346351146698,
+            0.0313548669219017,
+            0.08900952339172363,
+            -0.11672275513410568,
+            0.009228064678609371,
+            -0.06614221632480621,
+            0.08804277330636978,
+            0.014889740385115147,
+            0.0837869793176651,
+            0.052613452076911926
+        ],
+        [
+            0.007165177259594202,
+            0.09552574157714844,
+            0.04128532111644745,
+            0.23319952189922333,
+            0.04060375317931175,
+            0.004829184152185917,
+            -0.017625708132982254,
+            0.256346195936203,
+            -0.09568636119365692,
+            0.1217629685997963,
+            0.11848314851522446,
+            -0.0945698544383049,
+            0.2409045249223709,
+            -0.0642932578921318,
+            -0.07192564755678177,
+            -0.059860508888959885,
+            0.0038766765501350164,
+            0.07922583073377609,
+            -0.13200309872627258,
+            -0.008075611665844917,
+            -0.0718337669968605,
+            0.12349196523427963,
+            0.06138193607330322,
+            0.12523651123046875,
+            0.06255532801151276
+        ],
+        [
+            0.013663049787282944,
+            0.0896734818816185,
+            0.028995927423238754,
+            0.1750616431236267,
+            0.07454797625541687,
+            -0.00015515656559728086,
+            -0.023450186476111412,
+            0.25298011302948,
+            -0.09371822327375412,
+            0.13801263272762299,
+            0.0881008431315422,
+            -0.049779076129198074,
+            0.20126357674598694,
+            -0.07230399549007416,
+            -0.03318431228399277,
+            -0.06661950796842575,
+            -0.013055726885795593,
+            0.062482353299856186,
+            -0.10233037173748016,
+            0.0010978920618072152,
+            -0.05569494888186455,
+            0.07712023705244064,
+            0.09406734257936478,
+            0.14028283953666687,
+            0.07294159382581711
+        ],
+        [
+            0.007203482091426849,
+            0.10129950940608978,
+            0.039982035756111145,
+            0.23694902658462524,
+            0.04465002939105034,
+            0.022919295355677605,
+            -0.02517087012529373,
+            0.2456897497177124,
+            -0.09241221845149994,
+            0.10869739204645157,
+            0.10813245177268982,
+            -0.09005871415138245,
+            0.23983801901340485,
+            -0.05548616126179695,
+            -0.0680551677942276,
+            -0.0612766370177269,
+            0.012404014356434345,
+            0.08969696611166,
+            -0.13792237639427185,
+            0.0027189028915017843,
+            -0.07212885469198227,
+            0.12122439593076706,
+            0.049895964562892914,
+            0.11174862086772919,
+            0.0594610758125782
+        ],
+        [
+            0.015142648480832577,
+            0.10422768443822861,
+            0.04747527092695236,
+            0.24206401407718658,
+            0.06025819480419159,
+            0.047708068042993546,
+            -0.021447639912366867,
+            0.23014020919799805,
+            -0.07848216593265533,
+            0.0799720361828804,
+            0.08766385167837143,
+            -0.08673354238271713,
+            0.2412276715040207,
+            -0.043633200228214264,
+            -0.07271557301282883,
+            -0.047062892466783524,
+            0.02761814370751381,
+            0.101305291056633,
+            -0.15779165923595428,
+            0.018767476081848145,
+            -0.09160935878753662,
+            0.1384173333644867,
+            0.025102289393544197,
+            0.08094600588083267,
+            0.05143984034657478
+        ],
+        [
+            0.028154758736491203,
+            0.09565690904855728,
+            0.03274957835674286,
+            0.1944720596075058,
+            0.09666881710290909,
+            0.051757652312517166,
+            -0.03518573194742203,
+            0.24168984591960907,
+            -0.09000307321548462,
+            0.12017964571714401,
+            0.06792990118265152,
+            -0.060626767575740814,
+            0.2175217717885971,
+            -0.07149937748908997,
+            -0.02781124971807003,
+            -0.05420571565628052,
+            0.015406716614961624,
+            0.0798531025648117,
+            -0.1347212940454483,
+            0.009286892600357533,
+            -0.08278432488441467,
+            0.09549899399280548,
+            0.039724431931972504,
+            0.10764644294977188,
+            0.06264001131057739
+        ],
+        [
+            0.008391676470637321,
+            0.0973747968673706,
+            0.040743328630924225,
+            0.237803116440773,
+            0.04148852452635765,
+            0.013926422223448753,
+            -0.019263433292508125,
+            0.25254443287849426,
+            -0.09206318855285645,
+            0.11479611694812775,
+            0.11387477070093155,
+            -0.09368766844272614,
+            0.24319212138652802,
+            -0.06031264364719391,
+            -0.07428044080734253,
+            -0.057601600885391235,
+            0.008736682124435902,
+            0.08265452086925507,
+            -0.13998517394065857,
+            -0.0024266887921839952,
+            -0.07396848499774933,
+            0.12738429009914398,
+            0.05389825999736786,
+            0.11491165310144424,
+            0.0618685819208622
+        ],
+        [
+            0.006940770894289017,
+            0.09954819083213806,
+            0.039705246686935425,
+            0.2397753745317459,
+            0.03637868911027908,
+            0.00782571267336607,
+            -0.02053917571902275,
+            0.2577018737792969,
+            -0.09289030730724335,
+            0.1182500571012497,
+            0.1212732121348381,
+            -0.09443826973438263,
+            0.2449788898229599,
+            -0.060970794409513474,
+            -0.07778196781873703,
+            -0.060099635273218155,
+            0.00769026018679142,
+            0.07956616580486298,
+            -0.13944220542907715,
+            -0.0033730685245245695,
+            -0.07223784923553467,
+            0.1251903623342514,
+            0.0561370849609375,
+            0.11703293770551682,
+            0.0637783631682396
+        ],
+        [
+            0.010809740982949734,
+            0.08579500019550323,
+            0.04467885568737984,
+            0.23668628931045532,
+            0.03241227939724922,
+            0.007512611802667379,
+            -0.014459202997386456,
+            0.25426289439201355,
+            -0.09365314990282059,
+            0.11980917304754257,
+            0.12097729742527008,
+            -0.09833607822656631,
+            0.2425336092710495,
+            -0.06421089917421341,
+            -0.07231904566287994,
+            -0.059612978249788284,
+            0.002355606062337756,
+            0.07719527184963226,
+            -0.13177677989006042,
+            -0.009947814978659153,
+            -0.07172841578722,
+            0.125144362449646,
+            0.06410019844770432,
+            0.1278923749923706,
+            0.0638788491487503
+        ],
+        [
+            0.016090253368020058,
+            0.09943967312574387,
+            0.04487735778093338,
+            0.2356692999601364,
+            0.0489569753408432,
+            0.01849088817834854,
+            -0.02146572433412075,
+            0.24955835938453674,
+            -0.08736789226531982,
+            0.10283786803483963,
+            0.1084720566868782,
+            -0.09185444563627243,
+            0.24174976348876953,
+            -0.056078240275382996,
+            -0.07153630256652832,
+            -0.05393924191594124,
+            0.017149461433291435,
+            0.0823848769068718,
+            -0.14791782200336456,
+            0.005168371833860874,
+            -0.08274086564779282,
+            0.1315002292394638,
+            0.045013345777988434,
+            0.10639984905719757,
+            0.059141855686903
+        ],
+        [
+            0.006169868167489767,
+            0.09535106271505356,
+            0.041323691606521606,
+            0.23520100116729736,
+            0.04109320789575577,
+            0.009908515959978104,
+            -0.017406366765499115,
+            0.2538709044456482,
+            -0.09628500789403915,
+            0.11959456652402878,
+            0.11522892117500305,
+            -0.09686131030321121,
+            0.24163077771663666,
+            -0.0626436173915863,
+            -0.07307436317205429,
+            -0.05952596664428711,
+            0.004121786914765835,
+            0.08346229791641235,
+            -0.1316821277141571,
+            -0.007019544951617718,
+            -0.07161504030227661,
+            0.1257069855928421,
+            0.06002800911664963,
+            0.12318962812423706,
+            0.06023213267326355
+        ],
+        [
+            0.022201642394065857,
+            0.10250672698020935,
+            0.05509708821773529,
+            0.23794390261173248,
+            0.04126475751399994,
+            0.0115294074639678,
+            -0.011485804803669453,
+            0.23643307387828827,
+            -0.0674016997218132,
+            0.07847489416599274,
+            0.11564873903989792,
+            -0.0773441344499588,
+            0.22995322942733765,
+            -0.041648995131254196,
+            -0.07181819528341293,
+            -0.04582315310835838,
+            0.027515564113855362,
+            0.06658536940813065,
+            -0.15187978744506836,
+            0.0056944782845675945,
+            -0.07759997248649597,
+            0.13006313145160675,
+            0.025563061237335205,
+            0.09934639185667038,
+            0.05918028950691223
+        ],
+        [
+            0.00927142333239317,
+            0.09491042047739029,
+            0.041480958461761475,
+            0.23263737559318542,
+            0.04519198089838028,
+            0.011838705278933048,
+            -0.017354633659124374,
+            0.25323811173439026,
+            -0.09232158213853836,
+            0.11782632023096085,
+            0.11195020377635956,
+            -0.09382028132677078,
+            0.23995842039585114,
+            -0.06345298141241074,
+            -0.07126962393522263,
+            -0.05598864331841469,
+            0.005853781010955572,
+            0.0820014551281929,
+            -0.13455606997013092,
+            -0.005973884370177984,
+            -0.07581815868616104,
+            0.1255192756652832,
+            0.05786307528614998,
+            0.1209358349442482,
+            0.06007853150367737
+        ],
+        [
+            0.013185114599764347,
+            0.10104549676179886,
+            0.04050648584961891,
+            0.23008616268634796,
+            0.05514008551836014,
+            0.024909064173698425,
+            -0.02249046601355076,
+            0.24767619371414185,
+            -0.08714932203292847,
+            0.10788436979055405,
+            0.10305730253458023,
+            -0.08394972234964371,
+            0.2364301234483719,
+            -0.058491967618465424,
+            -0.06559315323829651,
+            -0.05567542836070061,
+            0.01419301237910986,
+            0.08302506804466248,
+            -0.1439053863286972,
+            0.005728192627429962,
+            -0.07961107790470123,
+            0.12200894951820374,
+            0.04537620022892952,
+            0.10679357498884201,
+            0.05982108414173126
+        ],
+        [
+            0.023377297446131706,
+            0.10460313409566879,
+            0.043298643082380295,
+            0.2239047884941101,
+            0.07540032267570496,
+            0.057078514248132706,
+            -0.03137959539890289,
+            0.2287401556968689,
+            -0.07376666367053986,
+            0.08620694279670715,
+            0.07402116060256958,
+            -0.07657094299793243,
+            0.23149941861629486,
+            -0.04998142272233963,
+            -0.059627994894981384,
+            -0.0468168780207634,
+            0.02899366430938244,
+            0.09978954493999481,
+            -0.1490432769060135,
+            0.021525178104639053,
+            -0.09080084413290024,
+            0.12457701563835144,
+            0.02673882059752941,
+            0.07885883003473282,
+            0.04937419667840004
+        ],
+        [
+            0.019687512889504433,
+            0.10798162966966629,
+            0.03777463361620903,
+            0.23290704190731049,
+            0.059821512550115585,
+            0.032761916518211365,
+            -0.028241654857993126,
+            0.24704350531101227,
+            -0.08324071019887924,
+            0.09956468641757965,
+            0.09815169870853424,
+            -0.08022316545248032,
+            0.23933802545070648,
+            -0.05404357239603996,
+            -0.0668841227889061,
+            -0.05337892472743988,
+            0.02144339308142662,
+            0.08303909748792648,
+            -0.15855589509010315,
+            0.01717006228864193,
+            -0.08386573940515518,
+            0.12461994588375092,
+            0.03309758007526398,
+            0.09138600528240204,
+            0.0626455545425415
+        ],
+        [
+            0.00813294854015112,
+            0.09869798272848129,
+            0.03916938230395317,
+            0.23841124773025513,
+            0.045117076486349106,
+            0.02053007297217846,
+            -0.019248390570282936,
+            0.2504102289676666,
+            -0.09294331818819046,
+            0.11405126005411148,
+            0.10832563787698746,
+            -0.09385287016630173,
+            0.242410808801651,
+            -0.0595259927213192,
+            -0.07331434637308121,
+            -0.058016687631607056,
+            0.008240411058068275,
+            0.08759854733943939,
+            -0.13813886046409607,
+            -0.0008130488567985594,
+            -0.0751105472445488,
+            0.12613731622695923,
+            0.05174552649259567,
+            0.11305583268404007,
+            0.05892980098724365
+        ],
+        [
+            0.008107729256153107,
+            0.10549106448888779,
+            0.03808220848441124,
+            0.22676551342010498,
+            0.06390149891376495,
+            0.048141960054636,
+            -0.030376985669136047,
+            0.23556110262870789,
+            -0.09152338653802872,
+            0.10808241367340088,
+            0.08341524004936218,
+            -0.08164401352405548,
+            0.23393172025680542,
+            -0.05396418273448944,
+            -0.06140049919486046,
+            -0.05954551324248314,
+            0.010931244120001793,
+            0.10232813656330109,
+            -0.13050982356071472,
+            0.007861025631427765,
+            -0.07186201214790344,
+            0.11350780725479126,
+            0.04264340177178383,
+            0.09792771935462952,
+            0.05414673686027527
+        ],
+        [
+            0.005319252144545317,
+            0.10500136762857437,
+            0.030668899416923523,
+            0.2395523488521576,
+            0.06927448511123657,
+            0.07929322868585587,
+            -0.03300244361162186,
+            0.22780966758728027,
+            -0.09471254050731659,
+            0.10341034084558487,
+            0.0679752379655838,
+            -0.09459913522005081,
+            0.24350903928279877,
+            -0.05525190010666847,
+            -0.06335707753896713,
+            -0.055353742092847824,
+            0.018912212923169136,
+            0.1204070970416069,
+            -0.1426607072353363,
+            0.018097996711730957,
+            -0.07917780429124832,
+            0.12469176948070526,
+            0.029479315504431725,
+            0.08488896489143372,
+            0.049824152141809464
+        ],
+        [
+            0.0069051869213581085,
+            0.09439900517463684,
+            0.04019998759031296,
+            0.23327870666980743,
+            0.04120791330933571,
+            0.006096913479268551,
+            -0.016819819808006287,
+            0.2567335367202759,
+            -0.09620301425457001,
+            0.12237152457237244,
+            0.11752248555421829,
+            -0.09571658819913864,
+            0.24046634137630463,
+            -0.06517498195171356,
+            -0.07135576754808426,
+            -0.059177521616220474,
+            0.0031766165047883987,
+            0.0791357010602951,
+            -0.13150028884410858,
+            -0.008791557513177395,
+            -0.07155582308769226,
+            0.12426675856113434,
+            0.06252951174974442,
+            0.12584315240383148,
+            0.06216191500425339
+        ],
+        [
+            0.01365884579718113,
+            0.10599631816148758,
+            0.04866413772106171,
+            0.2518925070762634,
+            0.03341028094291687,
+            0.01630610041320324,
+            -0.019486617296934128,
+            0.24552130699157715,
+            -0.07774272561073303,
+            0.09055454283952713,
+            0.12208399176597595,
+            -0.09083825349807739,
+            0.24840804934501648,
+            -0.045645251870155334,
+            -0.08133143931627274,
+            -0.05273433029651642,
+            0.024765441194176674,
+            0.0791550725698471,
+            -0.15983325242996216,
+            0.005109733436256647,
+            -0.07949142158031464,
+            0.13771763443946838,
+            0.028707748278975487,
+            0.09756610542535782,
+            0.05758548155426979
+        ],
+        [
+            0.007433218415826559,
+            0.09519690275192261,
+            0.042245298624038696,
+            0.23662085831165314,
+            0.04203767701983452,
+            0.01359939482063055,
+            -0.017286894842982292,
+            0.2522564232349396,
+            -0.09317891299724579,
+            0.11621575057506561,
+            0.11483917385339737,
+            -0.0965438187122345,
+            0.2418103665113449,
+            -0.06209199130535126,
+            -0.07282894849777222,
+            -0.05706195905804634,
+            0.008103624917566776,
+            0.08326420187950134,
+            -0.13559316098690033,
+            -0.006977047771215439,
+            -0.07452673465013504,
+            0.12749986350536346,
+            0.05531363561749458,
+            0.11921233683824539,
+            0.06044073775410652
+        ],
+        [
+            0.006716946139931679,
+            0.09473974257707596,
+            0.04029200226068497,
+            0.23366519808769226,
+            0.04185435548424721,
+            0.00863090343773365,
+            -0.016815435141324997,
+            0.2567133605480194,
+            -0.09557849168777466,
+            0.12329709529876709,
+            0.11586020141839981,
+            -0.09510437399148941,
+            0.24027343094348907,
+            -0.06561315059661865,
+            -0.0719337984919548,
+            -0.059463270008563995,
+            0.0034126299433410168,
+            0.08034070581197739,
+            -0.1318710744380951,
+            -0.008740792982280254,
+            -0.0724448636174202,
+            0.12414001673460007,
+            0.061260320246219635,
+            0.1253022998571396,
+            0.06106603518128395
+        ],
+        [
+            0.008236869238317013,
+            0.10531985014677048,
+            0.03207466006278992,
+            0.2376924604177475,
+            0.05935736000537872,
+            0.0517737939953804,
+            -0.03063468262553215,
+            0.23385754227638245,
+            -0.09232860058546066,
+            0.1044866070151329,
+            0.08605038374662399,
+            -0.089670330286026,
+            0.2408277988433838,
+            -0.05367361754179001,
+            -0.0641653835773468,
+            -0.058406658470630646,
+            0.012189309112727642,
+            0.10688704997301102,
+            -0.14101837575435638,
+            0.013549103401601315,
+            -0.07512913644313812,
+            0.12133827805519104,
+            0.04014192894101143,
+            0.0972670465707779,
+            0.053976692259311676
+        ],
+        [
+            0.019949035719037056,
+            0.09536083787679672,
+            0.0469941645860672,
+            0.2183641791343689,
+            0.07012058049440384,
+            0.042765822261571884,
+            -0.027695901691913605,
+            0.23698781430721283,
+            -0.08218743652105331,
+            0.1003064215183258,
+            0.08551587909460068,
+            -0.08570747822523117,
+            0.2352144867181778,
+            -0.059891197830438614,
+            -0.06135593727231026,
+            -0.044875361025333405,
+            0.019895579665899277,
+            0.09157855063676834,
+            -0.13741067051887512,
+            0.007180408108979464,
+            -0.08505664765834808,
+            0.128103107213974,
+            0.037349339574575424,
+            0.09363491088151932,
+            0.05485950782895088
+        ],
+        [
+            0.009191621094942093,
+            0.10088298469781876,
+            0.03861447796225548,
+            0.23986105620861053,
+            0.048122771084308624,
+            0.02703854627907276,
+            -0.02077867090702057,
+            0.2499948889017105,
+            -0.09244474023580551,
+            0.11166045814752579,
+            0.10528471320867538,
+            -0.09334976971149445,
+            0.2422584593296051,
+            -0.05943862721323967,
+            -0.07201159000396729,
+            -0.057053323835134506,
+            0.012986892834305763,
+            0.08865771442651749,
+            -0.1449781060218811,
+            0.0018293847097083926,
+            -0.0778854489326477,
+            0.12803703546524048,
+            0.047135841101408005,
+            0.1083567664027214,
+            0.05802663788199425
+        ],
+        [
+            0.01335360947996378,
+            0.09982048720121384,
+            0.036072149872779846,
+            0.224652960896492,
+            0.05331714078783989,
+            0.013235097751021385,
+            -0.023446256294846535,
+            0.26093700528144836,
+            -0.09593672305345535,
+            0.12425745278596878,
+            0.10834414511919022,
+            -0.08978825807571411,
+            0.23922881484031677,
+            -0.06736837327480316,
+            -0.06705943495035172,
+            -0.0562887005507946,
+            0.008668433874845505,
+            0.07711346447467804,
+            -0.14185665547847748,
+            0.0012954259291291237,
+            -0.07794482260942459,
+            0.1225513219833374,
+            0.05566534027457237,
+            0.1165541335940361,
+            0.06462220847606659
+        ],
+        [
+            0.014937380328774452,
+            0.10225769132375717,
+            0.03854452818632126,
+            0.22553230822086334,
+            0.05744883045554161,
+            0.019246429204940796,
+            -0.023629041388630867,
+            0.25225353240966797,
+            -0.08924926072359085,
+            0.11227662861347198,
+            0.1033308282494545,
+            -0.0792725682258606,
+            0.23615293204784393,
+            -0.059585269540548325,
+            -0.06336825340986252,
+            -0.0565621554851532,
+            0.012333432212471962,
+            0.07652176916599274,
+            -0.14627355337142944,
+            0.007538881618529558,
+            -0.07902007550001144,
+            0.11958126723766327,
+            0.047442179173231125,
+            0.10731709003448486,
+            0.06424443423748016
+        ],
+        [
+            0.006370713468641043,
+            0.09390486776828766,
+            0.04096357896924019,
+            0.2319260984659195,
+            0.04070279374718666,
+            0.004439717624336481,
+            -0.01595384255051613,
+            0.25754645466804504,
+            -0.09671463072299957,
+            0.12378624826669693,
+            0.1184261217713356,
+            -0.09516096860170364,
+            0.2394886016845703,
+            -0.06597548723220825,
+            -0.07113078236579895,
+            -0.05963036045432091,
+            0.002247217809781432,
+            0.07873374968767166,
+            -0.13007880747318268,
+            -0.010151155292987823,
+            -0.07096466422080994,
+            0.12399595975875854,
+            0.06405667960643768,
+            0.12728656828403473,
+            0.0618852861225605
+        ],
+        [
+            0.006017026025801897,
+            0.09636031836271286,
+            0.04014946147799492,
+            0.2350415289402008,
+            0.03976934030652046,
+            0.0053491778671741486,
+            -0.01596856117248535,
+            0.2580593228340149,
+            -0.09637302160263062,
+            0.12395194172859192,
+            0.11886228621006012,
+            -0.09626492857933044,
+            0.24167461693286896,
+            -0.0646955594420433,
+            -0.0735900029540062,
+            -0.059567779302597046,
+            0.0024835970252752304,
+            0.07951386272907257,
+            -0.13324518501758575,
+            -0.009371761232614517,
+            -0.07275794446468353,
+            0.12480863928794861,
+            0.0620453916490078,
+            0.12593255937099457,
+            0.06181560829281807
+        ],
+        [
+            0.01945938728749752,
+            0.11442819237709045,
+            0.03556836396455765,
+            0.23843950033187866,
+            0.06861675530672073,
+            0.055666372179985046,
+            -0.0321202427148819,
+            0.2394302636384964,
+            -0.08015631139278412,
+            0.09087998420000076,
+            0.07973586767911911,
+            -0.0768948644399643,
+            0.24322664737701416,
+            -0.04851270839571953,
+            -0.0712808147072792,
+            -0.04997728765010834,
+            0.030034879222512245,
+            0.09559392929077148,
+            -0.17107748985290527,
+            0.031292229890823364,
+            -0.09295233339071274,
+            0.1312979906797409,
+            0.019615069031715393,
+            0.07134952396154404,
+            0.058337025344371796
+        ],
+        [
+            0.013783090747892857,
+            0.09696712344884872,
+            0.043316494673490524,
+            0.23851437866687775,
+            0.04838531091809273,
+            0.027041302993893623,
+            -0.0219745896756649,
+            0.24226421117782593,
+            -0.08471459895372391,
+            0.09866517037153244,
+            0.1047210693359375,
+            -0.09481433779001236,
+            0.2425696849822998,
+            -0.053894128650426865,
+            -0.07156006991863251,
+            -0.05120214819908142,
+            0.015321014449000359,
+            0.09152235090732574,
+            -0.14155720174312592,
+            0.004323539789766073,
+            -0.08083559572696686,
+            0.13183878362178802,
+            0.04353334382176399,
+            0.10205719619989395,
+            0.055728670209646225
+        ],
+        [
+            0.005994858685880899,
+            0.09487453103065491,
+            0.04062533751130104,
+            0.23542821407318115,
+            0.03876492381095886,
+            0.0041758278384804726,
+            -0.016504650935530663,
+            0.25775548815727234,
+            -0.09646791964769363,
+            0.12193044275045395,
+            0.11933811753988266,
+            -0.09744102507829666,
+            0.2414218783378601,
+            -0.06483142077922821,
+            -0.073597751557827,
+            -0.05949563533067703,
+            0.002732417779043317,
+            0.07981766015291214,
+            -0.13177508115768433,
+            -0.00915740430355072,
+            -0.07138513028621674,
+            0.12512697279453278,
+            0.0635598823428154,
+            0.1267414093017578,
+            0.06236805021762848
+        ],
+        [
+            0.007926496677100658,
+            0.09517136961221695,
+            0.04121360927820206,
+            0.23354770243167877,
+            0.04149217531085014,
+            0.00656852126121521,
+            -0.017139777541160583,
+            0.25573042035102844,
+            -0.0946161076426506,
+            0.12002603709697723,
+            0.11685160547494888,
+            -0.0957757979631424,
+            0.24011193215847015,
+            -0.06331344693899155,
+            -0.07196789234876633,
+            -0.05795640870928764,
+            0.004703433718532324,
+            0.07934736460447311,
+            -0.133049875497818,
+            -0.0078008281998336315,
+            -0.07263065874576569,
+            0.12504954636096954,
+            0.06086507439613342,
+            0.12422352284193039,
+            0.06142197921872139
+        ],
+        [
+            0.011108269914984703,
+            0.11416453123092651,
+            0.041530828922986984,
+            0.23646694421768188,
+            0.07328485697507858,
+            0.07959862053394318,
+            -0.03905893489718437,
+            0.21185165643692017,
+            -0.0768301859498024,
+            0.07246819883584976,
+            0.06475184857845306,
+            -0.08046355098485947,
+            0.23789283633232117,
+            -0.035306207835674286,
+            -0.062330905348062515,
+            -0.04963645339012146,
+            0.03228869289159775,
+            0.1219068169593811,
+            -0.15246571600437164,
+            0.030902594327926636,
+            -0.08531811088323593,
+            0.12627369165420532,
+            0.015592117793858051,
+            0.06546328961849213,
+            0.04586423933506012
+        ]
+    ]
+}
\ No newline at end of file
diff --git a/docs/examples/robust_paper/scripts/create_datasets.py b/docs/examples/robust_paper/scripts/create_datasets.py
new file mode 100644
index 00000000..e3a206b5
--- /dev/null
+++ b/docs/examples/robust_paper/scripts/create_datasets.py
@@ -0,0 +1,207 @@
+import os
+import math
+import json
+import pickle
+import pyro
+from pyro.infer import Predictive
+
+from docs.examples.robust_paper.scripts.statics import (
+    LINK_FUNCTIONS_DICT,
+    MODELS,
+)
+from docs.examples.robust_paper.utils import uuid_from_config
+
+
+def save_config_and_data(
+    data_generator, config_dict, overwrite=False, **data_generator_kwargs
+):
+    # Create unique data uuid based on config
+    config_uuid = uuid_from_config(config_dict)
+
+    # Check if dataset already exists
+    if (
+        os.path.exists(f"docs/examples/robust_paper/datasets/{config_uuid}/data.pkl")
+        and not overwrite
+    ):
+        print(f"Dataset with uuid {config_uuid} already exists. Skipping.")
+        return
+
+    # Create directory for dataset if it doesn't exist
+    if not os.path.exists(f"docs/examples/robust_paper/datasets/{config_uuid}"):
+        os.makedirs(f"docs/examples/robust_paper/datasets/{config_uuid}")
+
+    # Save config
+    json.dump(
+        config_dict,
+        open(
+            f"docs/examples/robust_paper/datasets/{config_uuid}/config.json",
+            "w",
+        ),
+        indent=4,
+    )
+
+    # Simulate data
+    seed = config_dict["dataset_configs"]["seed"]
+    N = config_dict["model_configs"]["N"]
+    with pyro.poutine.seed(rng_seed=seed):
+        model = data_generator(**data_generator_kwargs)
+        D_train = Predictive(
+            model,
+            num_samples=N,
+            return_sites=model.observed_sites,
+        )()
+        D_test = Predictive(
+            model,
+            num_samples=N,
+            return_sites=model.observed_sites,
+        )()
+
+    # Save data
+    pickle.dump(
+        {
+            "train": D_train,
+            "test": D_test,
+        },
+        open(
+            f"docs/examples/robust_paper/datasets/{config_uuid}/data.pkl",
+            "wb",
+        ),
+    )
+    print(f"Saved dataset with uuid {config_uuid}.")
+
+
+def simulate_causal_glm_data(
+    seed,
+    link_function_str,
+    p,
+    N,
+    sparsity_level,
+    treatment_weight,
+    overwrite=False,
+):
+    model_str = "CausalGLM"
+    data_generator = MODELS[model_str]["data_generator"]
+    link_fn = LINK_FUNCTIONS_DICT[link_function_str]
+    alpha = math.ceil(sparsity_level * p)
+    beta = math.ceil(sparsity_level * p)
+    misc_kwargs = dict(
+        alpha=alpha,
+        beta=beta,
+        treatment_weight=treatment_weight,
+        sparsity_level=sparsity_level,
+    )
+    config_dict = {
+        "dataset_configs": {
+            "seed": seed,
+        },
+        "model_configs": {
+            "model_str": model_str,
+            "link_function_str": link_function_str,
+            "p": p,
+            "N": N,
+        },
+        "misc": misc_kwargs,
+    }
+    data_generator_kwargs = {
+        "p": p,
+        "link_fn": link_fn,
+        "alpha": alpha,
+        "beta": beta,
+        "treatment_weight": treatment_weight,
+    }
+    save_config_and_data(
+        data_generator, config_dict, overwrite=overwrite, **data_generator_kwargs
+    )
+
+
+def simulate_multivariate_normal(
+    seed,
+    p,
+    N,
+    overwrite=False,
+):
+    model_str = "MultivariateNormalModel"
+    data_generator = MODELS[model_str]["data_generator"]
+    misc_kwargs = dict()
+    config_dict = {
+        "dataset_configs": {
+            "seed": seed,
+        },
+        "model_configs": {
+            "model_str": model_str,
+            "p": p,
+            "N": N,
+        },
+        "misc": misc_kwargs,
+    }
+    data_generator_kwargs = {
+        "p": p,
+    }
+    save_config_and_data(
+        data_generator, config_dict, overwrite=overwrite, **data_generator_kwargs
+    )
+
+
+def simulate_kernel_ridge_data():
+    pass
+
+
+def simulate_neural_network_data():
+    pass
+
+
+def main_causal_glm(num_datasets_per_config=100, overwrite=False):
+    num_datasets_simulated = 0
+    # Effect of increasing dimensionality
+    for link_function_str in LINK_FUNCTIONS_DICT.keys():
+        for p in [1, 10, 100, 200, 500, 1000]:
+            for N in [500]:
+                for sparsity_level in [0.25]:
+                    for treatment_weight in [0.0, 1.0]:
+                        for seed in range(num_datasets_per_config):
+                            kwargs = {
+                                "seed": seed,
+                                "link_function_str": link_function_str,
+                                "p": p,
+                                "N": N,
+                                "sparsity_level": sparsity_level,
+                                "treatment_weight": treatment_weight,
+                                "overwrite": overwrite,
+                            }
+                            simulate_causal_glm_data(**kwargs)
+                            num_datasets_simulated += 1
+
+    # We can keep adding more configurations on the fly. Due to the `overwrite` flag,
+    # we can run this script multiple times and it will only simulate the datasets that
+    # *don't* already exist.
+
+    print(f"Simulated {num_datasets_simulated} datasets.")
+
+
+def main_multivariate_normal(num_datasets_per_config=100, overwrite=False):
+    num_datasets_simulated = 0
+    for p in [1, 2, 3]:
+        for N in [50]:
+            for seed in range(num_datasets_per_config):
+                kwargs = {
+                    "seed": seed,
+                    "p": p,
+                    "N": N,
+                    "overwrite": overwrite,
+                }
+                simulate_multivariate_normal(**kwargs)
+                num_datasets_simulated += 1
+    print(f"Simulated {num_datasets_simulated} datasets.")
+
+
+def main_kernel_ridge():
+    pass
+
+
+def main_neural_network():
+    pass
+
+
+if __name__ == "__main__":
+    main_causal_glm(5)
+    main_multivariate_normal(100)
diff --git a/docs/examples/robust_paper/scripts/create_experiment_configs.py b/docs/examples/robust_paper/scripts/create_experiment_configs.py
new file mode 100644
index 00000000..96581994
--- /dev/null
+++ b/docs/examples/robust_paper/scripts/create_experiment_configs.py
@@ -0,0 +1,107 @@
+import os
+import json
+from docs.examples.robust_paper.scripts.create_datasets import uuid_from_config
+from docs.examples.robust_paper.utils import get_valid_data_uuids
+from docs.examples.robust_paper.scripts.statics import ALL_DATA_CONFIGS
+
+
+def save_experiment_config(experiment_config):
+    experiment_uuid = uuid_from_config(experiment_config)
+    experiment_config["experiment_uuid"] = str(experiment_uuid)
+
+    experiment_config[
+        "results_path"
+    ] = f"docs/examples/robust_paper/experiments/{experiment_uuid}"
+
+    if not os.path.exists(f"docs/examples/robust_paper/experiments/{experiment_uuid}"):
+        os.makedirs(f"docs/examples/robust_paper/experiments/{experiment_uuid}")
+    json.dump(
+        experiment_config,
+        open(
+            f"docs/examples/robust_paper/experiments/{experiment_uuid}/config.json",
+            "w",
+        ),
+        indent=4,
+    )
+
+
+def influence_approx_experiment_ate():
+    valid_configs = []
+    for seed in range(25):
+        for p in [1, 10, 100, 200, 500]:
+            causal_glm_config_constraints = {
+                "dataset_configs": {
+                    "seed": seed,
+                },
+                "model_configs": {
+                    "model_str": "CausalGLM",
+                    "link_function_str": "normal",
+                    "N": 500,
+                    "p": p,
+                },
+                "misc": {
+                    "sparsity_level": 0.25,
+                    "treatment_weight": 0.0,
+                },
+            }
+            valid_configs.append(causal_glm_config_constraints)
+
+    valid_data_uuids = get_valid_data_uuids(valid_configs)
+
+    for uuid in valid_data_uuids:
+        experiment_config = {
+            "experiment_description": "Influence function approximation experiment",
+            "data_uuid": uuid,
+            "functional_str": "average_treatment_effect",
+            "functional_kwargs": {
+                "num_monte_carlo": 10000,
+            },
+            "monte_carlo_influence_estimator_kwargs": {
+                "num_samples_outer": [1000, 10000, 50000, 100000],
+                "num_samples_inner": 1,
+                "cg_iters": None,
+                "residual_tol": 1e-4,
+            },
+            "data_config": ALL_DATA_CONFIGS[uuid],
+        }
+        save_experiment_config(experiment_config)
+
+
+def influence_approx_experiment_expected_density():
+    valid_configs = []
+    mult_normal_config_constraints = {
+        "model_configs": {
+            "model_str": "MultivariateNormalModel",
+        },
+    }
+    valid_configs.append(mult_normal_config_constraints)
+    valid_data_uuids = get_valid_data_uuids(valid_configs)
+    for uuid in valid_data_uuids:
+        data_config = ALL_DATA_CONFIGS[uuid]
+        experiment_config = {
+            "experiment_description": "Influence function approximation experiment",
+            "data_uuid": uuid,
+            "functional_str": "expected_density",
+            "functional_kwargs": {
+                "num_monte_carlo": 10000,
+            },
+            "monte_carlo_influence_estimator_kwargs": {
+                "num_samples_outer": [1000, 10000, 50000, 100000],
+                "num_samples_inner": 1,
+                "cg_iters": None,
+                "residual_tol": 1e-4,
+            },
+            "fd_influence_estimator_kwargs": {
+                "lambdas": [0.1, 0.01, 0.001],
+                "epss": [0.1, 0.01, 0.001, 0.0001],
+                "num_samples_scaling": 100,
+                "seed": 0,
+            },
+            "data_config": data_config,
+        }
+        save_experiment_config(experiment_config)
+
+
+if __name__ == "__main__":
+    influence_approx_experiment_ate()
+    influence_approx_experiment_expected_density()
diff --git a/docs/examples/robust_paper/scripts/fd_influence_approx.py b/docs/examples/robust_paper/scripts/fd_influence_approx.py
new file mode 100644
index 00000000..6172a544
--- /dev/null
+++ b/docs/examples/robust_paper/scripts/fd_influence_approx.py
@@ -0,0 +1,183 @@
+from typing import List, Dict, Tuple
+import pyro
+import pyro.distributions as dist
+
+# TODO move these into __init__.py of finite_difference_eif for single import.
+from docs.examples.robust_paper.finite_difference_eif.mixins import (
+    NormalKernel,
+    ExpectedDensityMCFunctional,
+    ExpectedDensityQuadFunctional,
+)
+from docs.examples.robust_paper.finite_difference_eif.abstractions import (
+    fd_influence_fn,
+    FDModelFunctionalDensity,
+)
+from docs.examples.robust_paper.finite_difference_eif.distributions import (
+    PerturbableNormal,
+)
+import torch
+from itertools import product
+from chirho.robust.ops import Point, T
+
+# from docs.examples.robust_paper.utils import rng_seed_context
+import time
+import numpy as np
+from contextlib import contextmanager
+
+
+@contextmanager
+def rng_seed_context(seed: int):
+    og_rng_state = pyro.util.get_rng_state()
+    pyro.util.set_rng_seed(seed)
+    try:
+        yield
+    finally:
+        pyro.util.set_rng_state(og_rng_state)
+
+
+# Couple together perturbation kernels, perturbable models and functionals.
+class ExpectedNormalDensityQuadFunctional(
+    NormalKernel,
+    PerturbableNormal,
+    ExpectedDensityQuadFunctional,
+):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+class ExpectedNormalDensityMCFunctional(
+    NormalKernel,
+    PerturbableNormal,
+    ExpectedDensityMCFunctional,
+):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+def compute_fd_correction_sqd_mvn_quad(*, theta_hat: Point[T], **kwargs) -> List[Dict]:
+    mean = theta_hat["mu"].detach()
+    scale_tril = theta_hat["scale_tril"].detach()
+
+    fd_coupling = ExpectedNormalDensityQuadFunctional(
+        # TODO agnostic to names
+        default_kernel_point=dict(x=mean),
+        mean=mean,
+        scale_tril=scale_tril,
+    )
+
+    return compute_fd_correction(fd_coupling, **kwargs)
+
+
+def compute_fd_correction_sqd_mvn_mc(*, theta_hat: Point[T], **kwargs) -> List[Dict]:
+    mean = theta_hat["mu"].detach()
+    scale_tril = theta_hat["scale_tril"].detach()
+
+    fd_coupling = ExpectedNormalDensityMCFunctional(
+        # TODO agnostic to names
+        default_kernel_point=dict(x=mean),
+        mean=mean,
+        scale_tril=scale_tril,
+    )
+
+    return compute_fd_correction(fd_coupling, **kwargs)
+
+
+def compute_fd_correction(
+    fd_coupling: FDModelFunctionalDensity,
+    test_data: Point[T],
+    lambdas: List[float],
+    epss: List[float],
+    num_samples_scaling: int,
+    seed: int,
+) -> List[Dict]:
+    epslam = product(epss, lambdas)
+
+    results = list()
+
+    for eps, lambda_ in epslam:
+        result = dict()
+
+        with rng_seed_context(seed):
+            st = time.time()
+
+            # TODO HACK nmc depends on eps but only applies when fd_coupling.functional takes that argument.
+            #  Better ways to abstract this.
+            functional_kwargs = dict()
+            if isinstance(fd_coupling, ExpectedDensityMCFunctional):
+                functional_kwargs["nmc"] = int(num_samples_scaling / eps)
+
+            pointwise = fd_influence_fn(
+                fd_coupling=fd_coupling, points=test_data, eps=eps, lambda_=lambda_
+            )(**functional_kwargs)
+
+            result["wall_time"] = time.time() - st
+
+        result["eps"] = eps
+        result["lambda"] = lambda_
+        result["pointwise"] = [
+            y if isinstance(y, float) else y.item() for y in pointwise
+        ]
+        result["correction"] = np.mean(pointwise)
+
+        results.append(result)
+
+    return results
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+    import json
+
+    def smoke_test():
+        # Recommended values for experiments are commented out.
+        fd_kwargs = dict(
+            # lambdas=[0.1, 0.01, 0.001],
+            # epss=[0.1, 0.01, 0.001, 0.0001],
+            # num_samples_scaling=100,
+            # seed=0
+            lambdas=[0.001],
+            epss=[0.01, 0.001],
+            num_samples_scaling=10000,
+            seed=0,
+        )
+
+        # Runtime
+        for ndim in [1, 2]:
+            theta_hat = th = dict(
+                mu=torch.zeros(ndim), scale_tril=torch.linalg.cholesky(torch.eye(ndim))
+            )
+
+            test_data = dict(
+                x=dist.MultivariateNormal(
+                    loc=th["mu"], scale_tril=th["scale_tril"]
+                ).sample((20,))
+            )
+
+            mc_correction = compute_fd_correction_sqd_mvn_mc(
+                theta_hat=theta_hat, test_data=test_data, **fd_kwargs
+            )
+
+            quad_correction = compute_fd_correction_sqd_mvn_quad(
+                theta_hat=theta_hat, test_data=test_data, **fd_kwargs
+            )
+
+            # print("MC Correction")
+            # print(json.dumps(mc_correction, indent=2))
+            # print("Quad Correction")
+            # print(json.dumps(quad_correction, indent=2))
+
+            # Plot the quad correction results against the MC correction results. Fix aspect ratio.
+            for mc, qu in zip(mc_correction, quad_correction):
+                plt.figure()
+                plt.suptitle(f"D={ndim}, eps={mc['eps']}, lambda={mc['lambda']}")
+                plt.plot(mc["pointwise"], qu["pointwise"], "o")
+                plt.xlabel("MC Correction")
+                plt.ylabel("Quad Correction")
+                # Set xlim and ylim to the same range.
+                xymin = min(min(mc["pointwise"]), min(qu["pointwise"])) - 0.1
+                xymax = max(max(mc["pointwise"]), max(qu["pointwise"])) + 0.1
+                plt.xlim(xymin, xymax)
+                plt.ylim(xymin, xymax)
+                plt.show()
+
+    smoke_test()
diff --git a/docs/examples/robust_paper/scripts/influence_approx.py b/docs/examples/robust_paper/scripts/influence_approx.py
new file mode 100644
index 00000000..7881438a
--- /dev/null
+++ b/docs/examples/robust_paper/scripts/influence_approx.py
@@ -0,0 +1,244 @@
+import functools
+import time
+import torch
+import pickle
+from chirho.robust.handlers.predictive import PredictiveModel
+from chirho.robust.handlers.estimators import one_step_corrected_estimator
+from chirho.robust.ops import influence_fn
+from docs.examples.robust_paper.scripts.statics import (
+    LINK_FUNCTIONS_DICT,
+    FUNCTIONALS_DICT,
+    MODELS,
+    ALL_EXP_CONFIGS,
+)
+from docs.examples.robust_paper.utils import get_mle_params_and_guide, MLEGuide
+from docs.examples.robust_paper.analytic_eif import (
+    analytic_eif_expected_density,
+    analytic_eif_ate_causal_glm,
+)
+from fd_influence_approx import (
+    compute_fd_correction_sqd_mvn_mc,
+    compute_fd_correction_sqd_mvn_quad
+)
+
+
+def run_experiment(exp_config):
+    # Results dict
+    results = dict()
+    results["experiment_uuid"] = exp_config["experiment_uuid"]
+
+    # Load in data
+    data_config = exp_config["data_config"]
+    data = pickle.load(
+        open(
+            f"docs/examples/robust_paper/datasets/{exp_config['data_uuid']}/data.pkl",
+            "rb",
+        )
+    )
+    D_train = data["train"]
+    D_test = data["test"]
+
+    print(f"=== Running experiment {exp_config['experiment_uuid']} ===")
+
+    # Load in model
+    model_str = data_config["model_configs"]["model_str"]
+    if model_str == "MultivariateNormalModel":
+        model_kwargs = {
+            "p": data_config["model_configs"]["p"],
+        }
+    elif model_str == "CausalGLM":
+        model_kwargs = {
+            "p": data_config["model_configs"]["p"],
+            "link_fn": LINK_FUNCTIONS_DICT[
+                data_config["model_configs"]["link_function_str"]
+            ],
+        }
+    else:
+        raise NotImplementedError
+    model = MODELS[model_str]["model"](**model_kwargs)
+    conditioned_model = MODELS[model_str]["conditioned_model"](D_train, **model_kwargs)
+
+    # Load in functional
+    functional_str = exp_config["functional_str"]
+    functional_class = FUNCTIONALS_DICT[functional_str]
+    functional = functools.partial(functional_class, **exp_config["functional_kwargs"])
+
+    # Fit MLE
+    mle_start_time = time.time()
+    theta_hat, mle_guide = get_mle_params_and_guide(conditioned_model)
+    mle_end_time = time.time()
+    mle_time_min = (mle_end_time - mle_start_time) / 60.0
+    results["theta_hat"] = theta_hat
+    results["mle_time_min"] = mle_time_min
+
+    # Get plug-in estimate
+    plug_in_start_time = time.time()
+    plug_in_est = functional(PredictiveModel(model, mle_guide))()
+    plug_in_end_time = time.time()
+    plug_in_time_min = (plug_in_end_time - plug_in_start_time) / 60.0
+    results["plug_in_est"] = plug_in_est
+    results["plug_in_time_min"] = plug_in_time_min
+
+    #### Monte Carlo EIF ####
+    monte_eif_all_kwargs = exp_config["monte_carlo_influence_estimator_kwargs"]
+    num_samples_inner = monte_eif_all_kwargs["num_samples_inner"]
+    cg_iters = monte_eif_all_kwargs["cg_iters"]
+    residual_tol = monte_eif_all_kwargs["residual_tol"]
+    num_monte_carlo_outer_grid = monte_eif_all_kwargs["num_samples_outer"]
+    all_monte_carlo_eif_results = []
+
+    # Keeps erroring out due to https://github.com/BasisResearch/chirho/issues/483
+    for num_monte_carlo_outer in num_monte_carlo_outer_grid:
+        monte_carlo_eif_results = dict()
+        # Hack to avoid https://github.com/BasisResearch/chirho/issues/483
+        theta_hat = {
+            k: v.clone().detach().requires_grad_(True) for k, v in theta_hat.items()
+        }
+        mle_guide = MLEGuide(theta_hat)
+
+        print(f"Running monte carlo eif with {num_monte_carlo_outer} samples")
+        monte_carlo_eif_results["num_monte_carlo_outer"] = num_monte_carlo_outer
+        monte_kwargs = {
+            "num_samples_outer": num_monte_carlo_outer,
+            "num_samples_inner": num_samples_inner,
+            "cg_iters": cg_iters,
+            "residual_tol": residual_tol,
+        }
+
+        # One step estimator
+        monte_one_step_start = time.time()
+        one_step_estimator = one_step_corrected_estimator(
+            functional, D_test, **monte_kwargs
+        )
+        automated_monte_carlo_estimate = one_step_estimator(
+            PredictiveModel(model, mle_guide)
+        )()
+        monte_one_step_end = time.time()
+        monte_one_step_time_min = (monte_one_step_end - monte_one_step_start) / 60.0
+
+        monte_carlo_eif_results["wall_time"] = monte_one_step_time_min
+        monte_carlo_eif_results["correction"] = (
+            automated_monte_carlo_estimate - plug_in_est
+        )
+        monte_carlo_eif_results["corrected_estimate"] = automated_monte_carlo_estimate
+
+        # Hack to avoid https://github.com/BasisResearch/chirho/issues/483
+        theta_hat = {
+            k: v.clone().detach().requires_grad_(True) for k, v in theta_hat.items()
+        }
+        mle_guide = MLEGuide(theta_hat)
+
+        # Pointwise EIF
+        monte_eif_pointwise_start = time.time()
+        monte_eif = influence_fn(functional, D_test, **monte_kwargs)
+        monte_eif_at_test_pts = monte_eif(PredictiveModel(model, mle_guide))()
+        monte_eif_pointwise_end = time.time()
+        monte_eif_pointwise_time_min = (
+            monte_eif_pointwise_end - monte_eif_pointwise_start
+        ) / 60.0
+
+        monte_carlo_eif_results["pointwise_wall_time"] = monte_eif_pointwise_time_min
+        monte_carlo_eif_results["pointwise_eif"] = monte_eif_at_test_pts
+        all_monte_carlo_eif_results.append(monte_carlo_eif_results)
+
+    results["all_monte_carlo_eif_results"] = all_monte_carlo_eif_results
+
+    ### Finite Difference EIF ###
+    if model_str == "MultivariateNormalModel" and functional_str == "expected_density":
+        fd_kwargs = exp_config["fd_influence_estimator_kwargs"]
+        fd_mc_eif_results = compute_fd_correction_sqd_mvn_mc(
+            theta_hat=theta_hat,
+            test_data=D_test,
+            **fd_kwargs
+        )
+        results["fd_mc_eif_results"] = fd_mc_eif_results
+
+        # Maybe run this for 2d if you're having too good of a day, and need it to get worse.
+        if theta_hat["mu"].shape[-1] == 1:
+            fd_quad_eif_results = compute_fd_correction_sqd_mvn_quad(
+                theta_hat=theta_hat,
+                test_data=D_test,
+                **fd_kwargs
+            )
+            results["fd_quad_eif_results"] = fd_quad_eif_results
+
+    ### Analytic EIF ###
+    if model_str == "CausalGLM":
+        analytic_time_start = time.time()
+        analytic_correction, analytic_eif_at_test_pts = analytic_eif_ate_causal_glm(
+            D_test, theta_hat
+        )
+        analytic_time_end = time.time()
+        analytic_time_min = (analytic_time_end - analytic_time_start) / 60.0
+    elif model_str == "MultivariateNormalModel":
+        analytic_time_start = time.time()
+        analytic_correction, analytic_eif_at_test_pts = analytic_eif_expected_density(
+            D_test, plug_in_est, PredictiveModel(model, mle_guide)
+        )
+        analytic_time_end = time.time()
+        analytic_time_min = (analytic_time_end - analytic_time_start) / 60.0
+    else:
+        raise NotImplementedError
+
+    # Can't pickle _to_functional_tensor so convert to vanilla torch tensor
+    analytic_eif_results = dict()
+    analytic_eif_results["wall_time"] = analytic_time_min
+    analytic_eif_results["correction"] = torch.tensor(analytic_correction.item())
+    analytic_eif_results["corrected_estimate"] = (
+        plug_in_est + analytic_correction.item()
+    )
+    analytic_eif_results["pointwise_wall_time"] = analytic_time_min
+    analytic_eif_results["pointwise_eif"] = torch.tensor(
+        [e.item() for e in analytic_eif_at_test_pts]
+    )
+    results["analytic_eif_results"] = analytic_eif_results
+
+    # Save results
+    pickle.dump(
+        results,
+        open(
+            f"docs/examples/robust_paper/experiments/{exp_config['experiment_uuid']}/results.pkl",
+            "wb",
+        ),
+    )
+    return results
+
+
+if __name__ == "__main__":
+    from docs.examples.robust_paper.utils import get_valid_exp_uuids
+
+    # expected density
+    expected_density_config = {
+        "experiment_description": "Influence function approximation experiment",
+        "functional_str": "expected_density",
+        "data_config": {
+            "model_configs": {
+                "model_str": "MultivariateNormalModel",
+            },
+        },
+    }
+
+    # Run all expected density experiments
+    exp_uuids_for_density = get_valid_exp_uuids([expected_density_config])
+    for exp_uuid in exp_uuids_for_density:
+        exp_config = ALL_EXP_CONFIGS[exp_uuid]
+        print(run_experiment(exp_config))
+        break
+
+    # Run all ATE experiments
+    ate_config = {
+        "experiment_description": "Influence function approximation experiment",
+        "functional_str": "average_treatment_effect",
+        "data_config": {
+            "model_configs": {
+                "model_str": "CausalGLM",
+            },
+        },
+    }
+
+    # Run all ate experiments
+    exp_uuids_for_ate = get_valid_exp_uuids([ate_config])
+    for exp_uuid in exp_uuids_for_ate:
+        exp_config = ALL_EXP_CONFIGS[exp_uuid]
+        print(run_experiment(exp_config))
+        break
diff --git a/docs/examples/robust_paper/scripts/statics.py b/docs/examples/robust_paper/scripts/statics.py
new file mode 100644
index 00000000..32aae1b5
--- /dev/null
+++ b/docs/examples/robust_paper/scripts/statics.py
@@ -0,0 +1,54 @@
+import os
+import json
+import pyro.distributions as dist
+from docs.examples.robust_paper.models import *
+from docs.examples.robust_paper.functionals import *
+from docs.examples.robust_paper.finite_difference_eif.distributions import PerturbableNormal
+
+
+MODELS = {
+    "CausalGLM": {
+        "data_generator": DataGeneratorCausalGLM,
+        "model": CausalGLM,
+        "conditioned_model": ConditionedCausalGLM,
+    },
+    "MultivariateNormalModel": {
+        "data_generator": DataGeneratorMultivariateNormalModel,
+        "model": MultivariateNormalModel,
+        "conditioned_model": ConditionedMultivariateNormalModel,
+        "fd_perturbable_model": PerturbableNormal
+    },
+}
+
+LINK_FUNCTIONS_DICT = {
+    "normal": lambda mu: dist.Normal(mu, 1.0),
+    "bernoulli": lambda mu: dist.Bernoulli(logits=mu),
+}
+
+FUNCTIONALS_DICT = {
+    "average_treatment_effect": ATEFunctional,
+    "expected_density": ExpectedDensity,
+}
+
+EXPERIMENT_CATEGORIES = ["influence_approx", "estimator_approx", "capstone"]
+ESTIMATORS = ["plug_in", "tmle", "one_step", "double_ml"]
+INFLUENCE_ESTIMATORS = ["monte_carlo_eif", "analytical_eif", "finite_difference_eif"]
+ALL_DATA_UUIDS = [
+    d for d in os.listdir("docs/examples/robust_paper/datasets/") if d != ".DS_Store"
+]
+ALL_DATA_CONFIGS = {
+    uuid: json.load(
+        open(f"docs/examples/robust_paper/datasets/{uuid}/config.json", "r")
+    )
+    for uuid in ALL_DATA_UUIDS
+}
+
+ALL_EXP_UUIDS = [
+    d for d in os.listdir("docs/examples/robust_paper/experiments/") if d != ".DS_Store"
+]
+ALL_EXP_CONFIGS = {
+    uuid: json.load(
+        open(f"docs/examples/robust_paper/experiments/{uuid}/config.json", "r")
+    )
+    for uuid in ALL_EXP_UUIDS
+}
diff --git a/docs/examples/robust_paper/utils.py b/docs/examples/robust_paper/utils.py
new file mode 100644
index 00000000..bec1d6e0
--- /dev/null
+++ b/docs/examples/robust_paper/utils.py
@@ -0,0 +1,141 @@
+from typing import Dict, List
+import hashlib
+import uuid
+import json
+import torch
+import pyro
+from contextlib import contextmanager
+
+from chirho.robust.internals.utils import ParamDict
+from docs.examples.robust_paper.scripts.statics import (
+    ALL_DATA_CONFIGS,
+    ALL_DATA_UUIDS,
+    ALL_EXP_UUIDS,
+    ALL_EXP_CONFIGS,
+)
+
+
+pyro.settings.set(module_local_params=True)
+
+
+def uuid_from_config(config_dict):
+    serialized_config = json.dumps(config_dict, sort_keys=True)
+    hash_object = hashlib.sha1(serialized_config.encode())
+    hash_digest = hash_object.hexdigest()
+    return uuid.UUID(hash_digest[:32])
+
+
+def is_subset(superset: Dict, subset: Dict) -> bool:
+    """
+    Checks if a dictionary is a subset of another dictionary.
+    Source: https://stackoverflow.com/questions/49419486/
+    """
+    for key, value in subset.items():
+        if key not in superset:
+            return False
+
+        if isinstance(value, dict):
+            if not is_subset(superset[key], value):
+                return False
+
+        elif isinstance(value, str):
+            if value not in superset[key]:
+                return False
+
+        elif isinstance(value, list):
+            if not set(value) <= set(superset[key]):
+                return False
+        elif isinstance(value, set):
+            if not value <= superset[key]:
+                return False
+
+        else:
+            if not value == superset[key]:
+                return False
+
+    return True
+
+
+def any_is_subset(superset: Dict, subset: List[Dict]) -> bool:
+    """
+    Checks if any dictionary in a list of dictionaries is a subset of another dictionary.
+    """
+    for sub in subset:
+        if is_subset(superset, sub):
+            return True
+    return False
+
+
+def get_valid_data_uuids(valid_configs: List[Dict]) -> List[str]:
+    """
+    Gets the valid data uuids for a given set of configs.
+    """
+    valid_uuids = []
+    for uuid in ALL_DATA_UUIDS:
+        if any_is_subset(ALL_DATA_CONFIGS[uuid], valid_configs):
+            valid_uuids.append(uuid)
+    return valid_uuids
+
+
+def get_valid_exp_uuids(valid_configs: List[Dict]) -> List[str]:
+    """
+    Gets the valid experiment uuids for a given set of configs.
+    """
+    valid_uuids = []
+    for uuid in ALL_EXP_UUIDS:
+        if any_is_subset(ALL_EXP_CONFIGS[uuid], valid_configs):
+            valid_uuids.append(uuid)
+    return valid_uuids
+
+
+class MLEGuide(torch.nn.Module):
+    """
+    Helper class to create a trivial guide that returns the maximum likelihood estimate
+    """
+
+    def __init__(self, mle_est: ParamDict):
+        super().__init__()
+        self.names = list(mle_est.keys())
+        for name, value in mle_est.items():
+            setattr(self, name + "_param", torch.nn.Parameter(value))
+
+    def forward(self, *args, **kwargs):
+        for name in self.names:
+            value = getattr(self, name + "_param")
+            pyro.sample(
+                name, pyro.distributions.Delta(value, event_dim=len(value.shape))
+            )
+
+
+def get_mle_params_and_guide(conditioned_model, n_iters=2000, lr=0.03):
+    """
+    Returns the maximum likelihood estimate of the parameters of a model.
+    """
+    guide_train = pyro.infer.autoguide.AutoDelta(conditioned_model)
+    elbo = pyro.infer.Trace_ELBO()(conditioned_model, guide_train)
+
+    # initialize parameters
+    elbo()
+    adam = torch.optim.Adam(elbo.parameters(), lr=lr)
+
+    # Do gradient steps
+    for _ in range(n_iters):
+        adam.zero_grad()
+        loss = elbo()
+        loss.backward()
+        adam.step()
+
+    theta_hat = {
+        k: v.clone().detach().requires_grad_(True) for k, v in guide_train().items()
+    }
+    return theta_hat, MLEGuide(theta_hat)
+
+
+@contextmanager
+def rng_seed_context(seed: int):
+    og_rng_state = pyro.util.get_rng_state()
+    pyro.util.set_rng_seed(seed)
+    try:
+        yield
+    finally:
+        pyro.util.set_rng_state(og_rng_state)
\ No newline at end of file
diff --git a/docs/source/tmle.ipynb b/docs/source/tmle.ipynb
new file mode 100644
index 00000000..b9fe30e4
--- /dev/null
+++ b/docs/source/tmle.ipynb
@@ -0,0 +1,930 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Automated doubly robust estimation with ChiRho - TMLE Version"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Outline\n",
+    "\n",
+    "- [Setup](#setup)\n",
+    "\n",
+    "- [Overview: Systematically adjusting for observed confounding](#overview:-systematically-adjusting-for-observed-confounding)\n",
+    "    - [Task: Treatment effect estimation with observational data](#task:-treatment-effect-estimation-with-observational-data)\n",
+    "    - [Challenge: Confounding](#challenge:-confounding)\n",
+    "    - [Assumptions: All confounders observed](#assumptions:-all-confounders-observed)\n",
+    "    - [Intuition: Statistically adjusting for confounding](#intuition:-statistically-adjusting-for-confounding)\n",
+    "\n",
+    "- [Causal Probabilistic Program](#causal-probabilistic-program)\n",
+    "    - [Model description](#model-description)\n",
+    "    - [Generating data](#generating-data)\n",
+    "    - [Fit parameters via maximum likelihood](#fit-parameters-via-maximum-likelihood)\n",
+    "\n",
+    "- [Causal Query: average treatment effect (ATE)](#causal-query:-average-treatment-effect-\\(ATE\\))\n",
+    "    - [Defining the target functional](#defining-the-target-functional)\n",
+    "    - [Closed form doubly robust correction](#closed-form-doubly-robust-correction)\n",
+    "    - [Computing automated doubly robust correction via Monte Carlo](#computing-automated-doubly-robust-correction-via-monte-carlo)\n",
+    "    - [Results](#results)\n",
+    "\n",
+    "- [References](#references)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we install the necessary Pytorch, Pyro, and ChiRho dependencies for this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "NOTE: Redirects are currently not supported in Windows or MacOs.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from typing import Callable, Optional, Tuple\n",
+    "\n",
+    "import functools\n",
+    "import torch\n",
+    "import math\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import pyro\n",
+    "import pyro.distributions as dist\n",
+    "from pyro.infer import Predictive\n",
+    "import pyro.contrib.gp as gp\n",
+    "\n",
+    "from chirho.counterfactual.handlers import MultiWorldCounterfactual\n",
+    "from chirho.indexed.ops import IndexSet, gather\n",
+    "from chirho.interventional.handlers import do\n",
+    "from chirho.robust.internals.utils import ParamDict\n",
+    "from chirho.robust.handlers.estimators import one_step_corrected_estimator, tmle\n",
+    "from chirho.robust.handlers.predictive import PredictiveModel \n",
+    "from chirho.robust.ops import influence_fn\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "pyro.set_rng_seed(321) # for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "\n",
+    "In this tutorial, we will use ChiRho to estimate the average treatment effect (ATE) from observational data. We will use a simple example to illustrate the basic concepts of doubly robust estimation and how ChiRho can be used to automate the process for more general summaries of interest. \n",
+    "\n",
+    "There are five main steps to our doubly robust estimation procedure but only the last step is different from a standard probabilistic programming workflow:\n",
+    "1. Write model of interest\n",
+    "    - Define probabilistic model of interest using Pyro\n",
+    "2. Feed in data\n",
+    "    - Observed data used to train the model\n",
+    "3. Run inference\n",
+    "    - Use Pyro's rich inference library to fit the model to the data\n",
+    "4. Define target functional\n",
+    "    - This is the model summary of interest (e.g. average treatment effect)\n",
+    "5. Compute robust estimate\n",
+    "    - Use ChiRho to compute the doubly robust estimate of the target functional\n",
+    "    - Importantly, this step is automated and does not require refitting the model for each new functional\n",
+    "\n",
+    "\n",
+    "Our proposed automated robust inference pipeline is summarized in the figure below.\n",
+    "\n",
+    "![fig1](figures/robust_pipeline.png)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Causal Probabilistic Program\n",
+    "\n",
+    "### Model Description\n",
+    "In this example, we will focus on a cannonical model `CausalGLM` consisting of three types of variables: binary treatment (`A`), confounders (`X`), and response (`Y`). For simplicitly, we assume that the response is generated from a generalized linear model with link function $g$. The model is described by the following generative process:\n",
+    "\n",
+    "$$\n",
+    "\\begin{align*}\n",
+    "X &\\sim \\text{Normal}(0, I_p) \\\\\n",
+    "A &\\sim \\text{Bernoulli}(\\pi(X)) \\\\\n",
+    "\\mu &= \\beta_0 + \\beta_1^T X + \\tau A \\\\\n",
+    "Y &\\sim \\text{ExponentialFamily}(\\text{mean} = g^{-1}(\\mu))\n",
+    "\\end{align*}\n",
+    "$$\n",
+    "\n",
+    "where $p$ denotes the number of confounders, $\\pi(X)$ is the probability of treatment conditional on confounders $X$, $\\beta_0$ is the intercept, $\\beta_1$ is the confounder effect, and $\\tau$ is the treatment effect."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CausalGLM(pyro.nn.PyroModule):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        p: int,\n",
+    "        N: int,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        include_prior: bool = True,\n",
+    "        prior_scale: Optional[float] = None,\n",
+    "    ):\n",
+    "        super().__init__()\n",
+    "        self.p = p\n",
+    "        self.N = N\n",
+    "        self.link_fn = link_fn\n",
+    "        self.include_prior = include_prior\n",
+    "        if prior_scale is None:\n",
+    "            self.prior_scale = 1 / math.sqrt(self.p)\n",
+    "        else:\n",
+    "            self.prior_scale = prior_scale\n",
+    "\n",
+    "    def sample_outcome_weights(self):\n",
+    "        return pyro.sample(\n",
+    "            \"outcome_weights\",\n",
+    "            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),\n",
+    "        )\n",
+    "\n",
+    "    def sample_intercept(self):\n",
+    "        return pyro.sample(\"intercept\", dist.Normal(0.0, 1.0))\n",
+    "\n",
+    "    def sample_propensity_weights(self):\n",
+    "        return pyro.sample(\n",
+    "            \"propensity_weights\",\n",
+    "            dist.Normal(0.0, self.prior_scale).expand((self.p,)).to_event(1),\n",
+    "        )\n",
+    "\n",
+    "    def sample_treatment_weight(self):\n",
+    "        return pyro.sample(\"treatment_weight\", dist.Normal(0.0, 1.0))\n",
+    "\n",
+    "    def sample_covariate_loc_scale(self):\n",
+    "        return torch.zeros(self.p), torch.ones(self.p)\n",
+    "    \n",
+    "    def generate_datum(self, x_loc, x_scale, propensity_weights, outcome_weights, tau, intercept):\n",
+    "        X = pyro.sample(\"X\", dist.Normal(x_loc, x_scale).to_event(1))\n",
+    "        A = pyro.sample(\n",
+    "            \"A\",\n",
+    "            dist.Bernoulli(\n",
+    "                logits=torch.einsum(\"...i,...i->...\", X, propensity_weights)\n",
+    "            ),\n",
+    "        )\n",
+    "        return pyro.sample(\n",
+    "            \"Y\",\n",
+    "            self.link_fn(\n",
+    "                torch.einsum(\"...i,...i->...\", X, outcome_weights) + A * tau + intercept\n",
+    "            ),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self):\n",
+    "        with pyro.poutine.mask(mask=self.include_prior):\n",
+    "            intercept = self.sample_intercept()\n",
+    "            outcome_weights = self.sample_outcome_weights()\n",
+    "            propensity_weights = self.sample_propensity_weights()\n",
+    "            tau = self.sample_treatment_weight()\n",
+    "            x_loc, x_scale = self.sample_covariate_loc_scale()\n",
+    "        with pyro.plate(\"plate\", self.N, dim=-1):\n",
+    "            return self.generate_datum(x_loc, x_scale, propensity_weights, outcome_weights, tau, intercept)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we will condition on both treatment and confounders to estimate the causal effect of treatment on the outcome. We will use the following causal probabilistic program to do so:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ConditionedCausalGLM(CausalGLM):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        X: torch.Tensor,\n",
+    "        A: torch.Tensor,\n",
+    "        Y: torch.Tensor,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        include_prior: bool = True,\n",
+    "        prior_scale: Optional[float] = None,\n",
+    "    ):\n",
+    "        p = X.shape[1]\n",
+    "        N = X.shape[0]\n",
+    "        super().__init__(p, N, link_fn, include_prior, prior_scale)\n",
+    "        self.X = X\n",
+    "        self.A = A\n",
+    "        self.Y = Y\n",
+    "\n",
+    "    def forward(self):\n",
+    "        with pyro.condition(data={\"X\": self.X, \"A\": self.A, \"Y\": self.Y}):\n",
+    "            return super().forward()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<!-- Generated by graphviz version 6.0.2 (20221011.1828)\n",
+       " -->\n",
+       "<!-- Pages: 1 -->\n",
+       "<svg width=\"555pt\" height=\"304pt\"\n",
+       " viewBox=\"0.00 0.00 555.10 304.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
+       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 300)\">\n",
+       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-300 551.1,-300 551.1,4 -4,4\"/>\n",
+       "<g id=\"clust1\" class=\"cluster\">\n",
+       "<title>cluster_plate</title>\n",
+       "<polygon fill=\"none\" stroke=\"black\" points=\"93.6,-8 93.6,-265.5 183.6,-265.5 183.6,-8 93.6,-8\"/>\n",
+       "<text text-anchor=\"middle\" x=\"162.1\" y=\"-15.8\" font-family=\"Times,serif\" font-size=\"14.00\">plate</text>\n",
+       "</g>\n",
+       "<!-- intercept -->\n",
+       "<g id=\"node1\" class=\"node\">\n",
+       "<title>intercept</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"41.6\" cy=\"-129\" rx=\"41.69\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"41.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">intercept</text>\n",
+       "</g>\n",
+       "<!-- Y -->\n",
+       "<g id=\"node7\" class=\"node\">\n",
+       "<title>Y</title>\n",
+       "<ellipse fill=\"gray\" stroke=\"black\" cx=\"148.6\" cy=\"-57\" rx=\"27\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"148.6\" y=\"-53.3\" font-family=\"Times,serif\" font-size=\"14.00\">Y</text>\n",
+       "</g>\n",
+       "<!-- intercept&#45;&gt;Y -->\n",
+       "<g id=\"edge7\" class=\"edge\">\n",
+       "<title>intercept&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M63.51,-113.67C80.17,-102.77 103.2,-87.7 121.1,-75.99\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"123.48,-78.62 129.93,-70.21 119.64,-72.76 123.48,-78.62\"/>\n",
+       "</g>\n",
+       "<!-- outcome_weights -->\n",
+       "<g id=\"node2\" class=\"node\">\n",
+       "<title>outcome_weights</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"266.6\" cy=\"-129\" rx=\"73.39\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"266.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">outcome_weights</text>\n",
+       "</g>\n",
+       "<!-- outcome_weights&#45;&gt;Y -->\n",
+       "<g id=\"edge4\" class=\"edge\">\n",
+       "<title>outcome_weights&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M239.82,-112.12C221.12,-101.02 196.19,-86.23 177.12,-74.92\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"178.67,-71.77 168.28,-69.68 175.1,-77.79 178.67,-71.77\"/>\n",
+       "</g>\n",
+       "<!-- propensity_weights -->\n",
+       "<g id=\"node3\" class=\"node\">\n",
+       "<title>propensity_weights</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"270.6\" cy=\"-239.5\" rx=\"79.09\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"270.6\" y=\"-235.8\" font-family=\"Times,serif\" font-size=\"14.00\">propensity_weights</text>\n",
+       "</g>\n",
+       "<!-- A -->\n",
+       "<g id=\"node6\" class=\"node\">\n",
+       "<title>A</title>\n",
+       "<ellipse fill=\"gray\" stroke=\"black\" cx=\"148.6\" cy=\"-129\" rx=\"27\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"148.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">A</text>\n",
+       "</g>\n",
+       "<!-- propensity_weights&#45;&gt;A -->\n",
+       "<g id=\"edge1\" class=\"edge\">\n",
+       "<title>propensity_weights&#45;&gt;A</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M251.8,-221.78C230.28,-202.64 195,-171.27 171.79,-150.62\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"173.92,-147.84 164.12,-143.81 169.27,-153.07 173.92,-147.84\"/>\n",
+       "</g>\n",
+       "<!-- treatment_weight -->\n",
+       "<g id=\"node4\" class=\"node\">\n",
+       "<title>treatment_weight</title>\n",
+       "<ellipse fill=\"white\" stroke=\"black\" cx=\"430.6\" cy=\"-129\" rx=\"72.59\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"430.6\" y=\"-125.3\" font-family=\"Times,serif\" font-size=\"14.00\">treatment_weight</text>\n",
+       "</g>\n",
+       "<!-- treatment_weight&#45;&gt;Y -->\n",
+       "<g id=\"edge6\" class=\"edge\">\n",
+       "<title>treatment_weight&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M381.15,-115.73C324.52,-101.67 233.18,-79 183.5,-66.66\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"184.11,-63.21 173.56,-64.2 182.42,-70 184.11,-63.21\"/>\n",
+       "</g>\n",
+       "<!-- X -->\n",
+       "<g id=\"node5\" class=\"node\">\n",
+       "<title>X</title>\n",
+       "<ellipse fill=\"gray\" stroke=\"black\" cx=\"137.6\" cy=\"-239.5\" rx=\"27\" ry=\"18\"/>\n",
+       "<text text-anchor=\"middle\" x=\"137.6\" y=\"-235.8\" font-family=\"Times,serif\" font-size=\"14.00\">X</text>\n",
+       "</g>\n",
+       "<!-- X&#45;&gt;A -->\n",
+       "<g id=\"edge2\" class=\"edge\">\n",
+       "<title>X&#45;&gt;A</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M139.36,-221.07C141.11,-203.8 143.82,-177.12 145.85,-157.09\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"149.34,-157.33 146.87,-147.03 142.38,-156.63 149.34,-157.33\"/>\n",
+       "</g>\n",
+       "<!-- X&#45;&gt;Y -->\n",
+       "<g id=\"edge5\" class=\"edge\">\n",
+       "<title>X&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M129.33,-222.13C118.06,-197.6 100.6,-150.02 112.6,-111 115.88,-100.31 122.14,-89.85 128.52,-81.08\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"131.48,-82.98 134.85,-72.93 125.95,-78.69 131.48,-82.98\"/>\n",
+       "</g>\n",
+       "<!-- A&#45;&gt;Y -->\n",
+       "<g id=\"edge3\" class=\"edge\">\n",
+       "<title>A&#45;&gt;Y</title>\n",
+       "<path fill=\"none\" stroke=\"black\" d=\"M148.6,-110.7C148.6,-102.98 148.6,-93.71 148.6,-85.11\"/>\n",
+       "<polygon fill=\"black\" stroke=\"black\" points=\"152.1,-85.1 148.6,-75.1 145.1,-85.1 152.1,-85.1\"/>\n",
+       "</g>\n",
+       "<!-- distribution_description_node -->\n",
+       "<g id=\"node8\" class=\"node\">\n",
+       "<title>distribution_description_node</title>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-280.8\" font-family=\"Times,serif\" font-size=\"14.00\">intercept ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-265.8\" font-family=\"Times,serif\" font-size=\"14.00\">outcome_weights ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-250.8\" font-family=\"Times,serif\" font-size=\"14.00\">propensity_weights ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-235.8\" font-family=\"Times,serif\" font-size=\"14.00\">treatment_weight ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-220.8\" font-family=\"Times,serif\" font-size=\"14.00\">X ~ Normal</text>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-205.8\" font-family=\"Times,serif\" font-size=\"14.00\">A ~ Bernoulli</text>\n",
+       "<text text-anchor=\"start\" x=\"376.1\" y=\"-190.8\" font-family=\"Times,serif\" font-size=\"14.00\">Y ~ Normal</text>\n",
+       "</g>\n",
+       "</g>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<graphviz.graphs.Digraph at 0x186117450>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Visualize the model\n",
+    "pyro.render_model(\n",
+    "    ConditionedCausalGLM(torch.zeros(1, 1), torch.zeros(1), torch.zeros(1)),\n",
+    "    render_params=True, \n",
+    "    render_distributions=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generating data\n",
+    "\n",
+    "For evaluation, we generate `N_datasets` datasets, each with `N` samples. We compare vanilla estimates of the target functional with the double robust estimates of the target functional across the `N_sims` datasets. We use a similar data generating process as in Kennedy (2022)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class GroundTruthModel(CausalGLM):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        p: int,\n",
+    "        N: int,\n",
+    "        alpha: int,\n",
+    "        beta: int,\n",
+    "        link_fn: Callable[..., dist.Distribution] = lambda mu: dist.Normal(mu, 1.0),\n",
+    "        treatment_weight: float = 0.0,\n",
+    "    ):\n",
+    "        super().__init__(p, N, link_fn)\n",
+    "        self.alpha = alpha  # sparsity of propensity weights\n",
+    "        self.beta = beta  # sparsity of outcome weights\n",
+    "        self.treatment_weight = treatment_weight\n",
+    "\n",
+    "    def sample_outcome_weights(self):\n",
+    "        outcome_weights = 1 / math.sqrt(self.beta) * torch.ones(self.p)\n",
+    "        outcome_weights[self.beta :] = 0.0\n",
+    "        return outcome_weights\n",
+    "\n",
+    "    def sample_propensity_weights(self):\n",
+    "        propensity_weights = 1 / math.sqrt(self.alpha) * torch.ones(self.p)\n",
+    "        propensity_weights[self.alpha :] = 0.0\n",
+    "        return propensity_weights\n",
+    "\n",
+    "    def sample_treatment_weight(self):\n",
+    "        return torch.tensor(self.treatment_weight)\n",
+    "\n",
+    "    def sample_intercept(self):\n",
+    "        return torch.tensor(0.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N_datasets = 50\n",
+    "simulated_datasets = []\n",
+    "\n",
+    "# Data configuration\n",
+    "p = 200\n",
+    "alpha = 50\n",
+    "beta = 50\n",
+    "N_train = 500\n",
+    "N_test = 500\n",
+    "treatment_weight = 1.0\n",
+    "\n",
+    "true_model = GroundTruthModel(p, N_train+N_test, alpha, beta, treatment_weight=treatment_weight)\n",
+    "prior_model = CausalGLM(p, N_train+N_test)\n",
+    "\n",
+    "# Generate data\n",
+    "D = Predictive(true_model, num_samples=N_datasets, return_sites=[\"X\", \"A\", \"Y\"], parallel=True)()\n",
+    "D_train = {k: v[:, :N_train] for k, v in D.items()}\n",
+    "D_test = {k: v[:, N_train:] for k, v in D.items()}\n",
+    "\n",
+    "# D_train : (N_datasets, N_train, p)\n",
+    "# D_test : (N_datasets, N_test, p)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Fit parameters via maximum likelihood"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0\n",
+      "tensor(143220.2969, grad_fn=<AddBackward0>)\n",
+      "tensor(142401.8281, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.5000, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.5000, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.5312, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.5000, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.6094, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.6094, grad_fn=<AddBackward0>)\n",
+      "tensor(142398.6562, grad_fn=<AddBackward0>)\n",
+      "1\n",
+      "tensor(142864.0625, grad_fn=<AddBackward0>)\n",
+      "tensor(142156.9531, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7969, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7812, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.8281, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.8125, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.8906, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.9688, grad_fn=<AddBackward0>)\n",
+      "tensor(142155.7969, grad_fn=<AddBackward0>)\n",
+      "2\n",
+      "tensor(143104.5469, grad_fn=<AddBackward0>)\n",
+      "tensor(142385.0469, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3750, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3906, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.5156, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3750, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3906, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3594, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.4062, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.4375, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.4062, grad_fn=<AddBackward0>)\n",
+      "tensor(142384.3906, grad_fn=<AddBackward0>)\n",
+      "3\n",
+      "tensor(142825.3125, grad_fn=<AddBackward0>)\n",
+      "tensor(142005.4062, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4688, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4688, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4688, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4688, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4688, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.5000, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.5000, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.5156, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.5156, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.4844, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.7188, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.5938, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.6094, grad_fn=<AddBackward0>)\n",
+      "tensor(142000.5000, grad_fn=<AddBackward0>)\n",
+      "4\n",
+      "tensor(143287.3281, grad_fn=<AddBackward0>)\n",
+      "tensor(142508.1094, grad_fn=<AddBackward0>)\n",
+      "tensor(142506.4531, grad_fn=<AddBackward0>)\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[13], line 20\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2000\u001b[39m):\n\u001b[1;32m     19\u001b[0m     adam\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[0;32m---> 20\u001b[0m     loss \u001b[38;5;241m=\u001b[39m \u001b[43melbo\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     21\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m j \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m100\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m     22\u001b[0m         \u001b[38;5;28mprint\u001b[39m(loss)\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/torch/nn/modules/module.py:1501\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1496\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1497\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1499\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1500\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1502\u001b[0m \u001b[38;5;66;03m# Do not call functions when jit is used\u001b[39;00m\n\u001b[1;32m   1503\u001b[0m full_backward_hooks, non_full_backward_hooks \u001b[38;5;241m=\u001b[39m [], []\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/infer/elbo.py:25\u001b[0m, in \u001b[0;36mELBOModule.forward\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     24\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 25\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43melbo\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdifferentiable_loss\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mguide\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/infer/trace_elbo.py:121\u001b[0m, in \u001b[0;36mTrace_ELBO.differentiable_loss\u001b[0;34m(self, model, guide, *args, **kwargs)\u001b[0m\n\u001b[1;32m    119\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.0\u001b[39m\n\u001b[1;32m    120\u001b[0m surrogate_loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.0\u001b[39m\n\u001b[0;32m--> 121\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m model_trace, guide_trace \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_traces(model, guide, args, kwargs):\n\u001b[1;32m    122\u001b[0m     loss_particle, surrogate_loss_particle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_differentiable_loss_particle(\n\u001b[1;32m    123\u001b[0m         model_trace, guide_trace\n\u001b[1;32m    124\u001b[0m     )\n\u001b[1;32m    125\u001b[0m     surrogate_loss \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m surrogate_loss_particle \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_particles\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/infer/elbo.py:237\u001b[0m, in \u001b[0;36mELBO._get_traces\u001b[0;34m(self, model, guide, args, kwargs)\u001b[0m\n\u001b[1;32m    235\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    236\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_particles):\n\u001b[0;32m--> 237\u001b[0m         \u001b[38;5;28;01myield\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_get_trace\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mguide\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/infer/trace_elbo.py:57\u001b[0m, in \u001b[0;36mTrace_ELBO._get_trace\u001b[0;34m(self, model, guide, args, kwargs)\u001b[0m\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_get_trace\u001b[39m(\u001b[38;5;28mself\u001b[39m, model, guide, args, kwargs):\n\u001b[1;32m     53\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     54\u001b[0m \u001b[38;5;124;03m    Returns a single trace from the guide, and the model that is run\u001b[39;00m\n\u001b[1;32m     55\u001b[0m \u001b[38;5;124;03m    against it.\u001b[39;00m\n\u001b[1;32m     56\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m---> 57\u001b[0m     model_trace, guide_trace \u001b[38;5;241m=\u001b[39m \u001b[43mget_importance_trace\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     58\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mflat\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmax_plate_nesting\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mguide\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m     59\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     60\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m is_validation_enabled():\n\u001b[1;32m     61\u001b[0m         check_if_enumerated(guide_trace)\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/infer/enum.py:75\u001b[0m, in \u001b[0;36mget_importance_trace\u001b[0;34m(graph_type, max_plate_nesting, model, guide, args, kwargs, detach)\u001b[0m\n\u001b[1;32m     72\u001b[0m guide_trace \u001b[38;5;241m=\u001b[39m prune_subsample_sites(guide_trace)\n\u001b[1;32m     73\u001b[0m model_trace \u001b[38;5;241m=\u001b[39m prune_subsample_sites(model_trace)\n\u001b[0;32m---> 75\u001b[0m \u001b[43mmodel_trace\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute_log_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     76\u001b[0m guide_trace\u001b[38;5;241m.\u001b[39mcompute_score_parts()\n\u001b[1;32m     77\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_validation_enabled():\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/poutine/trace_struct.py:230\u001b[0m, in \u001b[0;36mTrace.compute_log_prob\u001b[0;34m(self, site_filter)\u001b[0m\n\u001b[1;32m    228\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlog_prob\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m site:\n\u001b[1;32m    229\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 230\u001b[0m         log_p \u001b[38;5;241m=\u001b[39m \u001b[43msite\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mfn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    231\u001b[0m \u001b[43m            \u001b[49m\u001b[43msite\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mvalue\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msite\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43margs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msite\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mkwargs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m    232\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    233\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    234\u001b[0m         _, exc_value, traceback \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mexc_info()\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/torch/distributions/independent.py:99\u001b[0m, in \u001b[0;36mIndependent.log_prob\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m     98\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mlog_prob\u001b[39m(\u001b[38;5;28mself\u001b[39m, value):\n\u001b[0;32m---> 99\u001b[0m     log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbase_dist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlog_prob\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    100\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m _sum_rightmost(log_prob, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mreinterpreted_batch_ndims)\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/torch/distributions/normal.py:83\u001b[0m, in \u001b[0;36mNormal.log_prob\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m     81\u001b[0m var \u001b[38;5;241m=\u001b[39m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m     82\u001b[0m log_scale \u001b[38;5;241m=\u001b[39m math\u001b[38;5;241m.\u001b[39mlog(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale) \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale, Real) \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale\u001b[38;5;241m.\u001b[39mlog()\n\u001b[0;32m---> 83\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m-\u001b[39m(\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m) \u001b[38;5;241m/\u001b[39m (\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m var) \u001b[38;5;241m-\u001b[39m log_scale \u001b[38;5;241m-\u001b[39m math\u001b[38;5;241m.\u001b[39mlog(math\u001b[38;5;241m.\u001b[39msqrt(\u001b[38;5;241m2\u001b[39m \u001b[38;5;241m*\u001b[39m math\u001b[38;5;241m.\u001b[39mpi))\n",
+      "File \u001b[0;32m~/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/torch/_tensor.py:34\u001b[0m, in \u001b[0;36m_handle_torch_function_and_wrap_type_error_to_not_implemented.<locals>.wrapped\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_handle_torch_function_and_wrap_type_error_to_not_implemented\u001b[39m(f):\n\u001b[1;32m     32\u001b[0m     assigned \u001b[38;5;241m=\u001b[39m functools\u001b[38;5;241m.\u001b[39mWRAPPER_ASSIGNMENTS\n\u001b[0;32m---> 34\u001b[0m     \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(f, assigned\u001b[38;5;241m=\u001b[39massigned)\n\u001b[1;32m     35\u001b[0m     \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrapped\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m     36\u001b[0m         \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     37\u001b[0m             \u001b[38;5;66;03m# See https://github.com/pytorch/pytorch/issues/75462\u001b[39;00m\n\u001b[1;32m     38\u001b[0m             \u001b[38;5;28;01mif\u001b[39;00m has_torch_function(args):\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "fitted_params = []\n",
+    "for i in range(N_datasets):\n",
+    "    print(i)\n",
+    "\n",
+    "    # Fit model using maximum likelihood\n",
+    "    conditioned_model = ConditionedCausalGLM(\n",
+    "        X=D_train[\"X\"][i], A=D_train[\"A\"][i], Y=D_train[\"Y\"][i]\n",
+    "    )\n",
+    "    \n",
+    "    guide_train = pyro.infer.autoguide.AutoDelta(conditioned_model)\n",
+    "    elbo = pyro.infer.Trace_ELBO()(conditioned_model, guide_train)\n",
+    "\n",
+    "    # initialize parameters\n",
+    "    elbo()\n",
+    "    adam = torch.optim.Adam(elbo.parameters(), lr=0.03)\n",
+    "\n",
+    "    # Do gradient steps\n",
+    "    for j in range(2000):\n",
+    "        adam.zero_grad()\n",
+    "        loss = elbo()\n",
+    "        if j % 100 == 0:\n",
+    "            print(loss)\n",
+    "        loss.backward()\n",
+    "        adam.step()\n",
+    "\n",
+    "    theta_hat = {\n",
+    "        k: v.clone().detach().requires_grad_(True) for k, v in guide_train().items()\n",
+    "    }\n",
+    "    fitted_params.append(theta_hat)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Causal Query: Sample Average treatment effect (ATE)\n",
+    "\n",
+    "The average treatment effect summarizes, on average, how much the treatment changes the response, $ATE = \\mathbb{E}[Y|do(A=1)] - \\mathbb{E}[Y|do(A=0)]$. The `do` notation indicates that the expectations are taken according to *intervened* versions of the model, with $A$ set to a particular value. Note from our [tutorial](tutorial_i.ipynb) that this is different from conditioning on $A$ in the original `causal_model`, which assumes $X$ and $T$ are dependent.\n",
+    "\n",
+    "\n",
+    "To implement this query in ChiRho, we define the `SATEFunctional` class which take in a `model` and `guide` and returns the average treatment effect by simulating from the posterior predictive distribution of the model and guide."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Defining the target functional"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class SATEFunctional(torch.nn.Module):\n",
+    "    def __init__(self, model: Callable, *, num_monte_carlo: int = 100):\n",
+    "        super().__init__()\n",
+    "        self.model = model\n",
+    "        self.num_monte_carlo = num_monte_carlo\n",
+    "    \n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        with MultiWorldCounterfactual():\n",
+    "            with do(actions=dict(A=(torch.tensor(0.0), torch.tensor(1.0)))):\n",
+    "                Ys = self.model(*args, **kwargs)\n",
+    "            Y0 = gather(Ys, IndexSet(A={1}), event_dim=0)\n",
+    "            Y1 = gather(Ys, IndexSet(A={2}), event_dim=0)\n",
+    "        sate = (Y1 - Y0).mean(dim=-1, keepdim=True).squeeze()\n",
+    "        return pyro.deterministic(\"SATE\", sate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SATE = SATEFunctional(true_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Closed form doubly robust correction\n",
+    "\n",
+    "For the average treatment effect functional, there exists a closed-form analytical formula for the doubly robust correction. This formula is derived in Kennedy (2022) and is implemented below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Any\n",
+    "from chirho.robust.ops import Functional, Point, P, S, T\n",
+    "\n",
+    "def SATECausalGLM_analytic_influence(functional: Functional[P, S], \n",
+    "                                    point: Point[T], \n",
+    "                                    pointwise_influence: bool = True,\n",
+    "                                    **kwargs) -> Functional[P, S]:\n",
+    "    # assert isinstance(functional, SATEFunctional)\n",
+    "    def new_functional(model: Callable[P, Any]) -> Callable[P, S]:\n",
+    "        assert isinstance(model.model, CausalGLM)\n",
+    "        theta = dict(model.guide.named_parameters())\n",
+    "        def new_model(*args, **kwargs):\n",
+    "            X = point[\"X\"]\n",
+    "            A = point[\"A\"]\n",
+    "            Y = point[\"Y\"]\n",
+    "            \n",
+    "            pi_X = torch.sigmoid(torch.einsum(\"...i,...i->...\", X, theta[\"propensity_weights_param\"]))\n",
+    "            mu_X = (\n",
+    "                torch.einsum(\"...i,...i->...\", X, theta[\"outcome_weights_param\"])\n",
+    "                + A * theta[\"treatment_weight_param\"]\n",
+    "                + theta[\"intercept_param\"]\n",
+    "            )\n",
+    "            analytic_eif_at_pts = (A / pi_X - (1 - A) / (1 - pi_X)) * (Y - mu_X)\n",
+    "            if pointwise_influence:\n",
+    "                return analytic_eif_at_pts\n",
+    "            else:\n",
+    "                return analytic_eif_at_pts.mean()\n",
+    "\n",
+    "\n",
+    "        return new_model\n",
+    "    return new_functional\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Closed form expression\n",
+    "# def closed_form_doubly_robust_ate_correction(X_test, theta) -> Tuple[torch.Tensor, torch.Tensor]:\n",
+    "#     X = X_test[\"X\"]\n",
+    "#     A = X_test[\"A\"]\n",
+    "#     Y = X_test[\"Y\"]\n",
+    "#     pi_X = torch.sigmoid(X.mv(theta[\"propensity_weights\"]))\n",
+    "#     mu_X = (\n",
+    "#         X.mv(theta[\"outcome_weights\"])\n",
+    "#         + A * theta[\"treatment_weight\"]\n",
+    "#         + theta[\"intercept\"]\n",
+    "#     )\n",
+    "#     analytic_eif_at_test_pts = (A / pi_X - (1 - A) / (1 - pi_X)) * (Y - mu_X)\n",
+    "#     analytic_correction = analytic_eif_at_test_pts.mean()\n",
+    "#     return analytic_correction, analytic_eif_at_test_pts"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Computing automated doubly robust correction via Monte Carlo\n",
+    "\n",
+    "While the doubly robust correction term is known in closed-form for the average treatment effect functional, our `one_step_correction` function in `ChiRho` works for a wide class of other functionals. We focus on the average treatment effect functional here so that we have a ground truth to compare `one_step_correction` against."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tracemalloc\n",
+    "\n",
+    "tracemalloc.start()\n",
+    "\n",
+    "# Helper class to create a trivial guide that returns the maximum likelihood estimate\n",
+    "class MLEGuide(torch.nn.Module):\n",
+    "    def __init__(self, mle_est: ParamDict):\n",
+    "        super().__init__()\n",
+    "        self.names = list(mle_est.keys())\n",
+    "        for name, value in mle_est.items():\n",
+    "            setattr(self, name + \"_param\", torch.nn.Parameter(value))\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        for name in self.names:\n",
+    "            value = getattr(self, name + \"_param\")\n",
+    "            pyro.sample(\n",
+    "                name, pyro.distributions.Delta(value, event_dim=len(value.shape))\n",
+    "            )\n",
+    "\n",
+    "# Compute doubly robust ATE estimates using both the automated and closed form expressions\n",
+    "# estimators = {\"tmle\": tmle, \"one_step\": one_step_corrected_estimator}\n",
+    "estimators = {\"one_step\": one_step_corrected_estimator}\n",
+    "estimator_kwargs = {\"tmle\": {\"learning_rate\":5e-5,\n",
+    "                \"n_grad_steps\":500,\n",
+    "                \"n_tmle_steps\":1,\n",
+    "                \"num_nmc_samples\":1000,\n",
+    "                \"num_grad_samples\":N_test}, \"one_step\": {}}\n",
+    "# influences = {\"analytic\": SATECausalGLM_analytic_influence, \"monte_carlo\": influence_fn}\n",
+    "influences = {\"analytic\": SATECausalGLM_analytic_influence}\n",
+    "\n",
+    "estimates = {f\"{influence}-{estimator}\": torch.zeros(N_datasets) for influence in influences.keys() for estimator in estimators.keys()}\n",
+    "estimates[\"plug-in-mle\"] = torch.zeros(N_datasets)\n",
+    "estimates[\"plug-in-prior\"] = torch.zeros(N_datasets)\n",
+    "estimates[\"plug-in-truth\"] = torch.zeros(N_datasets)\n",
+    "\n",
+    "functional = functools.partial(SATEFunctional, num_monte_carlo=10000)\n",
+    "\n",
+    "for i in range(N_datasets):\n",
+    "    print(\"plug-in-prior\", i)\n",
+    "    estimates[\"plug-in-prior\"][i] = functional(prior_model)().item()\n",
+    "\n",
+    "    print(\"plug-in-truth\", i)\n",
+    "    estimates[\"plug-in-truth\"][i] = functional(true_model)().item()\n",
+    "\n",
+    "    # D_test = simulated_datasets[i][1]\n",
+    "    theta_hat = fitted_params[i]\n",
+    "    mle_guide = MLEGuide(theta_hat)\n",
+    "\n",
+    "    model = PredictiveModel(CausalGLM(p, N_test), mle_guide)\n",
+    "    \n",
+    "    print(\"plug-in-mle\", i)\n",
+    "    estimates[\"plug-in-mle\"][i] = functional(model)().detach().item()\n",
+    "\n",
+    "    for estimator_str, estimator in estimators.items():\n",
+    "        for influence_str, influence in influences.items():\n",
+    "            if estimator_str == \"tmle\" and influence_str == \"monte_carlo\":\n",
+    "                continue\n",
+    "\n",
+    "            print(estimator_str, influence_str, i)\n",
+    "            \n",
+    "            estimate = estimator(\n",
+    "                functional, \n",
+    "                {\"X\": D_test[\"X\"][i], \"A\": D_test[\"A\"][i], \"Y\": D_test[\"Y\"][i]},\n",
+    "                num_samples_outer=max(10000, 100 * p), \n",
+    "                num_samples_inner=1,\n",
+    "                influence_estimator=influence,\n",
+    "                **estimator_kwargs[estimator_str]\n",
+    "            )(model)()\n",
+    "\n",
+    "            estimates[f\"{influence_str}-{estimator_str}\"][i] = estimate.detach().item()\n",
+    "\n",
+    "    print(tracemalloc.get_traced_memory())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = pd.DataFrame(estimates)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# The true treatment effect is 0, so a mean estimate closer to zero is better\n",
+    "results.describe().round(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Visualize the results\n",
+    "fig, ax = plt.subplots()\n",
+    "\n",
+    "for col in results.columns:\n",
+    "    sns.kdeplot(results[col], ax=ax, label=col)\n",
+    "\n",
+    "ax.axvline(treatment_weight, color=\"black\", label=\"True ATE\", linestyle=\"--\")\n",
+    "ax.set_yticks([])\n",
+    "sns.despine()\n",
+    "ax.legend(loc=\"upper right\")\n",
+    "ax.set_xlabel(\"ATE Estimate\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plt.scatter(\n",
+    "#     results['automated_monte_carlo_correction'],\n",
+    "#     results['analytic_correction'],\n",
+    "# )\n",
+    "# plt.plot(np.linspace(-.2, .5), np.linspace(-.2, .5), color=\"black\", linestyle=\"dashed\")\n",
+    "# plt.xlabel(\"DR-Monte Carlo\")\n",
+    "# plt.ylabel(\"DR-Analytic\")\n",
+    "# sns.despine()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "\n",
+    "Kennedy, Edward. \"Towards optimal doubly robust estimation of heterogeneous causal effects\", 2022. https://arxiv.org/abs/2004.14497."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "basis",
+   "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.11.4"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/setup.py b/setup.py
index 47c6dcd3..da1536f9 100644
--- a/setup.py
+++ b/setup.py
@@ -25,6 +25,7 @@
 ]
 
 DYNAMICAL_REQUIRE = ["torchdiffeq"]
+ROBUST_REQUIRE = ["torchopt"]
 
 setup(
     name="chirho",
@@ -41,12 +42,13 @@
     install_requires=[
         # if you add any additional libraries, please also
         # add them to `docs/source/requirements.txt`
-        "pyro-ppl>=1.8.5",
+        "pyro-ppl==1.8.6",
     ],
     extras_require={
         "dynamical": DYNAMICAL_REQUIRE,
+        "robust": ROBUST_REQUIRE,
         "extras": EXTRAS_REQUIRE,
-        "test": EXTRAS_REQUIRE + DYNAMICAL_REQUIRE
+        "test": EXTRAS_REQUIRE + DYNAMICAL_REQUIRE + ROBUST_REQUIRE
         + [
             "pytest",
             "pytest-cov",
diff --git a/tests/robust/test_handlers.py b/tests/robust/test_handlers.py
index e4301528..9cd55e74 100644
--- a/tests/robust/test_handlers.py
+++ b/tests/robust/test_handlers.py
@@ -1,3 +1,4 @@
+import copy
 import functools
 from typing import Callable, List, Mapping, Optional, Set, Tuple, TypeVar
 
@@ -6,7 +7,7 @@
 import torch
 from typing_extensions import ParamSpec
 
-from chirho.robust.handlers.estimators import one_step_corrected_estimator
+from chirho.robust.handlers.estimators import one_step_corrected_estimator, tmle
 from chirho.robust.handlers.predictive import PredictiveFunctional, PredictiveModel
 
 from .robust_fixtures import SimpleGuide, SimpleModel
@@ -42,7 +43,7 @@
 @pytest.mark.parametrize("num_samples_outer,num_samples_inner", [(10, None), (10, 100)])
 @pytest.mark.parametrize("cg_iters", [None, 1, 10])
 @pytest.mark.parametrize("num_predictive_samples", [1, 5])
-@pytest.mark.parametrize("estimation_method", [one_step_corrected_estimator])
+@pytest.mark.parametrize("estimation_method", [one_step_corrected_estimator, tmle])
 def test_estimator_smoke(
     model,
     guide,
@@ -66,6 +67,20 @@ def test_estimator_smoke(
             )().items()
         }
 
+    predictive_model = PredictiveModel(model, guide)
+
+    prev_params = copy.deepcopy(dict(predictive_model.named_parameters()))
+
+    if estimation_method == tmle:
+        estimator_kwargs = {
+            "n_tmle_steps": 1,
+            "n_grad_steps": 2,
+            "num_nmc_samples": 10,
+            "num_grad_samples": 10,
+        }
+    else:
+        estimator_kwargs = {}
+
     estimator = estimation_method(
         functools.partial(PredictiveFunctional, num_samples=num_predictive_samples),
         test_datum,
@@ -73,7 +88,8 @@ def test_estimator_smoke(
         num_samples_outer=num_samples_outer,
         num_samples_inner=num_samples_inner,
         cg_iters=cg_iters,
-    )(PredictiveModel(model, guide))
+        **estimator_kwargs,
+    )(predictive_model)
 
     estimate_on_test: Mapping[str, torch.Tensor] = estimator()
     assert len(estimate_on_test) > 0
@@ -83,3 +99,8 @@ def test_estimator_smoke(
         assert not torch.isclose(
             v, torch.zeros_like(v)
         ).all(), f"{estimation_method} estimator for {k} was zero"
+
+    # Assert estimator doesn't have side effects on model parameters.
+    new_params = dict(predictive_model.named_parameters())
+    for k, v in prev_params.items():
+        assert torch.allclose(v, new_params[k]), f"{k} was updated"