diff --git a/doc/spec/estimation/forest.rst b/doc/spec/estimation/forest.rst index 5dab326c7..5ded4181e 100644 --- a/doc/spec/estimation/forest.rst +++ b/doc/spec/estimation/forest.rst @@ -363,8 +363,7 @@ and the `ForestLearners Jupyter notebook >> est.fit(Y, T, W, W) >>> print(est.effect(W[:2])) - [[1. ] - [1.2]] + [1.00... 1.19...] Similarly, we can call :class:`.DiscreteTreatmentOrthoForest`: @@ -377,7 +376,7 @@ Similarly, we can call :class:`.DiscreteTreatmentOrthoForest`: >>> est.fit(Y, T, W, W) >>> print(est.effect(W[:2])) - [1. 1.2] + [1.01... 1.25...] Let's now look at a more involved example with a high-dimensional set of confounders :math:`W` and with more realistic noisy data. In this case we can just use the default parameters diff --git a/doc/spec/inference.rst b/doc/spec/inference.rst index 1e036773f..911cd0fe0 100644 --- a/doc/spec/inference.rst +++ b/doc/spec/inference.rst @@ -136,6 +136,27 @@ and the :class:`.ForestDRLearner`. You can enable such intervals by setting ``in This inference is enabled by our implementation of the :class:`.SubsampledHonestForest` extension to the scikit-learn :class:`~sklearn.ensemble.RandomForestRegressor`. + +OrthoForest Bootstrap of Little Bags Inference +============================================== + +For the Orthogonal Random Forest estimators (see :class:`.ContinuousTreatmentOrthoForest`, :class:`.DiscreteTreatmentOrthoForest`), +we provide confidence intervals built via the bootstrap-of-little-bags approach ([Athey2019]_). This technique is well suited for +estimating the uncertainty of the honest causal forests underlying the OrthoForest estimators. You can enable such intervals by setting +``inference='blb'``, e.g.: + +.. testcode:: + + from econml.ortho_forest import ContinuousTreatmentOrthoForest + from econml.sklearn_extensions.linear_model import WeightedLasso + est = ContinuousTreatmentOrthoForest(n_trees=10, + min_leaf_size=3, + model_T=WeightedLasso(alpha=0.01), + model_Y=WeightedLasso(alpha=0.01)) + est.fit(y, t, X, W, inference='blb') + point = est.const_marginal_effect(X) + lb, ub = est.const_marginal_effect_interval(X, alpha=0.05) + .. todo:: * Subsampling * Doubly Robust Gradient Inference diff --git a/econml/ortho_forest.py b/econml/ortho_forest.py index 1dcd419f9..378763237 100644 --- a/econml/ortho_forest.py +++ b/econml/ortho_forest.py @@ -26,6 +26,7 @@ import warnings from joblib import Parallel, delayed from sklearn import clone +from scipy.stats import norm from sklearn.exceptions import NotFittedError from sklearn.linear_model import LassoCV, Lasso, LinearRegression, LogisticRegression, \ LogisticRegressionCV, ElasticNet @@ -36,6 +37,7 @@ from .sklearn_extensions.linear_model import WeightedLassoCVWrapper from .cate_estimator import BaseCateEstimator, LinearCateEstimator, TreatmentExpansionMixin from .causal_tree import CausalTree +from .inference import Inference from .utilities import reshape, reshape_Y_T, MAX_RAND_SEED, check_inputs, cross_product @@ -174,6 +176,9 @@ def __init__(self, self.forest_two_trees = None self.forest_one_subsample_ind = None self.forest_two_subsample_ind = None + # Auxiliary attributes + self.n_slices = int(np.ceil((self.n_trees)**(1 / 2))) + self.slice_len = int(np.ceil(self.n_trees / self.n_slices)) # Fit check self.model_is_fitted = False super().__init__() @@ -198,7 +203,7 @@ def fit(self, Y, T, X, W=None, inference=None): inference: string, :class:`.Inference` instance, or None Method for performing inference. This estimator supports 'bootstrap' - (or an instance of :class:`.BootstrapInference`) + (or an instance of :class:`.BootstrapInference`) and 'blb' (or an instance of :class:`BLBInference`) Returns ------- @@ -231,6 +236,7 @@ def fit(self, Y, T, X, W=None, inference=None): X=self.X_two, W=self.W_two) self.model_is_fitted = True + return self def const_marginal_effect(self, X): """Calculate the constant marginal CATE θ(·) conditional on a vector of features X. @@ -253,7 +259,24 @@ def const_marginal_effect(self, X): # TODO: Check performance return np.asarray(results) - def _pointwise_effect(self, X_single): + def _get_inference_options(self): + # Override the CATE inference options + # Add blb inference to parent's options + options = super()._get_inference_options() + options.update(blb=BLBInference) + return options + + def _pointwise_effect(self, X_single, stderr=False): + """Calculate the effect for a one data point with features X_single. + + Parameters + ---------- + X_single : array-like, shape (d_x, ) + Feature vector that captures heterogeneity for one sample. + + stderr : boolean (default=False) + Whether to calculate the covariance matrix via bootstrap-of-little-bags. + """ w1, w2 = self._get_weights(X_single) mask_w1 = (w1 != 0) mask_w2 = (w2 != 0) @@ -278,23 +301,49 @@ def _pointwise_effect(self, X_single): np.concatenate((self.T_one[mask_w1], self.T_two[mask_w2])), np.concatenate((self.X_one[mask_w1], self.X_two[mask_w2])), nuisance_estimates, - w_nonzero + w_nonzero, + X_single ) + # ------------------------------------------------------------------------------- + # Calculate the covariance matrix corresponding to the BLB inference + # + # 1. Calculate the moments and gradient of the training data w.r.t the test point + # 2. Calculate the weighted moments for each tree slice to create a matrix + # U = (n_slices, n_T). The V = (U x grad^{-1}) matrix represents the deviation + # in that slice from the overall parameter estimate. + # 3. Calculate the covariance matrix (V.T x V) / n_slices + # ------------------------------------------------------------------------------- + if stderr: + moments, mean_grad = self.moment_and_mean_gradient_estimator( + np.concatenate((self.Y_one[mask_w1], self.Y_two[mask_w2])), + np.concatenate((self.T_one[mask_w1], self.T_two[mask_w2])), + np.concatenate((self.X_one[mask_w1], self.X_two[mask_w2])), + np.concatenate((self.W_one[mask_w1], self.W_two[mask_w2])) if self.W_one is not None else None, + nuisance_estimates, + parameter_estimate) + # Calclulate covariance matrix through BLB + slices = [ + (it * self.slice_len, min((it + 1) * self.slice_len, self.n_trees)) for it in range(self.n_slices) + ] + slice_weighted_moment_one = [] + slice_weighted_moment_two = [] + for slice_it in slices: + slice_weights_one, slice_weights_two = self._get_weights(X_single, tree_slice=slice_it) + slice_weighted_moment_one.append( + np.average(moments[:len(w1_nonzero)], axis=0, weights=slice_weights_one[mask_w1]) + ) + slice_weighted_moment_two.append( + np.average(moments[len(w1_nonzero):], axis=0, weights=slice_weights_two[mask_w2]) + ) + U = np.vstack(slice_weighted_moment_one + slice_weighted_moment_two) + inverse_grad = np.linalg.inv(mean_grad) + cov_mat = inverse_grad.T @ U.T @ U @ inverse_grad / (2 * self.n_slices) + return parameter_estimate, cov_mat return parameter_estimate def _fit_forest(self, Y, T, X, W=None): # Generate subsample indices - if self.bootstrap: - subsample_ind = self.random_state.choice(X.shape[0], size=(self.n_trees, X.shape[0]), replace=True) - else: - if self.subsample_ratio > 1.0: - # Safety check - self.subsample_ratio = 1.0 - subsample_size = int(self.subsample_ratio * X.shape[0]) - subsample_ind = np.zeros((self.n_trees, subsample_size)) - for t in range(self.n_trees): - subsample_ind[t] = self.random_state.choice(X.shape[0], size=subsample_size, replace=False) - subsample_ind = subsample_ind.astype(int) + subsample_ind = self._get_blb_indices(X) # Build trees in parallel return subsample_ind, Parallel(n_jobs=self.n_jobs, verbose=3, max_nbytes=None)( delayed(_build_tree_in_parallel)( @@ -305,12 +354,20 @@ def _fit_forest(self, Y, T, X, W=None): self.min_leaf_size, self.max_depth, self.random_state.randint(MAX_RAND_SEED)) for s in subsample_ind) - def _get_weights(self, X_single): - # Calculates weights + def _get_weights(self, X_single, tree_slice=None): + """Calculate weights for a single input feature vector over a subset of trees. + + The subset of trees is defined by the `tree_slice` tuple (start, end). + The (start, end) tuple includes all trees from `start` to `end`-1. + """ w1 = np.zeros(self.Y_one.shape[0]) w2 = np.zeros(self.Y_two.shape[0]) - for t, tree in enumerate(self.forest_one_trees): - leaf = tree.find_split(X_single) + if tree_slice is None: + tree_range = range(self.n_trees) + else: + tree_range = range(*tree_slice) + for t in tree_range: + leaf = self.forest_one_trees[t].find_split(X_single) weight_indexes = self.forest_one_subsample_ind[t][leaf.est_sample_inds] leaf_weight = 1 / len(leaf.est_sample_inds) if self.bootstrap: @@ -319,8 +376,8 @@ def _get_weights(self, X_single): w1[unique] += leaf_weight * counts else: w1[weight_indexes] += leaf_weight - for t, tree in enumerate(self.forest_two_trees): - leaf = tree.find_split(X_single) + for t in tree_range: + leaf = self.forest_two_trees[t].find_split(X_single) # Similar for `a` weights weight_indexes = self.forest_two_subsample_ind[t][leaf.est_sample_inds] leaf_weight = 1 / len(leaf.est_sample_inds) @@ -330,7 +387,28 @@ def _get_weights(self, X_single): w2[unique] += leaf_weight * counts else: w2[weight_indexes] += leaf_weight - return (w1 / self.n_trees, w2 / self.n_trees) + return (w1 / len(tree_range), w2 / len(tree_range)) + + def _get_blb_indices(self, X): + """Get data indices for every tree under the little bags split.""" + # Define subsample size + subsample_size = X.shape[0] // 2 + if not self.bootstrap: + if self.subsample_ratio > 1.0: + # Safety check + warnings.warn("The argument 'subsample_ratio' must be between 0.0 and 1.0, " + + "however a value of {} was provided. The 'subsample_ratio' will be changed to 1.0.") + self.subsample_ratio = 1.0 + subsample_size = int(self.subsample_ratio * subsample_size) + subsample_ind = [] + # Draw points to create little bags + for it in range(self.n_slices): + half_sample_inds = self.random_state.choice( + X.shape[0], X.shape[0] // 2, replace=False) + for _ in np.arange(it * self.slice_len, min((it + 1) * self.slice_len, self.n_trees)): + subsample_ind.append(half_sample_inds[self.random_state.choice( + X.shape[0] // 2, subsample_size, replace=self.bootstrap)]) + return np.asarray(subsample_ind) class ContinuousTreatmentOrthoForest(BaseOrthoForest): @@ -441,18 +519,14 @@ def __init__(self, n_jobs=n_jobs, random_state=random_state) - def _pointwise_effect(self, X_single): - """ - We need to post-process the parameters returned by the _pointwise_effect - of the BaseOrthoForest class due to the local linear correction. The - base class function will return the intercept and the coefficient of the - local linear fit. We multiply it with the input co-variate to get the - predicted effect. - """ - parameter = super(ContinuousTreatmentOrthoForest, self)._pointwise_effect(X_single) - X_aug = np.append([1], X_single) - parameter = parameter.reshape((X_aug.shape[0], -1)).T - return np.dot(parameter, X_aug) + def const_marginal_effect(self, X): + # Override to flatten output if T is flat + effects = super(ContinuousTreatmentOrthoForest, self).const_marginal_effect(X=X) + if not self._d_t: + # T is flat + return effects.flatten() + return effects + const_marginal_effect.__doc__ = BaseOrthoForest.const_marginal_effect.__doc__ @staticmethod def nuisance_estimator_generator(model_T, model_Y, random_state=None, second_stage=True): @@ -509,8 +583,13 @@ def second_stage_parameter_estimator_gen(lambda_reg): """ def parameter_estimator_func(Y, T, X, nuisance_estimates, - sample_weight=None): - """Calculate the parameter of interest for points given by (Y, T) and corresponding nuisance estimates.""" + sample_weight, + X_single): + """Calculate the parameter of interest for points given by (Y, T) and corresponding nuisance estimates. + + The parameter is calculated around the feature vector given by `X_single`. `X_single` can be used to do + local corrections on a preliminary parameter estimate. + """ # Compute residuals Y_hat, T_hat = nuisance_estimates Y_res, T_res = reshape_Y_T(Y - Y_hat, T - T_hat) @@ -526,11 +605,13 @@ def parameter_estimator_func(Y, T, X, diagonal[:T_res.shape[1]] = 0 reg = lambda_reg * np.diag(diagonal) # Ridge regression estimate - param_estimate = np.linalg.lstsq(np.matmul(weighted_XT_res.T, XT_res) + reg, - np.matmul(weighted_XT_res.T, Y_res.reshape(-1, 1)), - rcond=None)[0].flatten() - # Parameter returned by LinearRegression is (d_T, ) - return param_estimate + linear_coef_estimate = np.linalg.lstsq(np.matmul(weighted_XT_res.T, XT_res) + reg, + np.matmul(weighted_XT_res.T, Y_res.reshape(-1, 1)), + rcond=None)[0].flatten() + X_aug = np.append([1], X_single) + linear_coef_estimate = linear_coef_estimate.reshape((X_aug.shape[0], -1)).T + # Parameter returned is of shape (d_T, ) + return np.dot(linear_coef_estimate, X_aug) return parameter_estimator_func @@ -716,19 +797,6 @@ def fit(self, Y, T, X, W=None, inference=None): # Call `fit` from parent class return super().fit(Y, T, X, W=W, inference=inference) - def _pointwise_effect(self, X_single): - """ - We need to post-process the parameters returned by the _pointwise_effect - of the BaseOrthoForest class due to the local linear correction. The - base class function will return the intercept and the coefficient of the - local linear fit. We multiply it with the input co-variate to get the - predicted effect. - """ - parameter = super(DiscreteTreatmentOrthoForest, self)._pointwise_effect(X_single) - X_aug = np.append([1], X_single) - parameter = parameter.reshape((X_aug.shape[0], -1)).T - return np.dot(parameter, X_aug) - @staticmethod def nuisance_estimator_generator(propensity_model, model_Y, n_T, random_state=None, second_stage=False): """Generate nuissance estimator given model inputs from the class.""" @@ -792,8 +860,13 @@ def second_stage_parameter_estimator_gen(lambda_reg): """ def parameter_estimator_func(Y, T, X, nuisance_estimates, - sample_weight=None): - """Calculate the parameter of interest for points given by (Y, T) and corresponding nuisance estimates.""" + sample_weight, + X_single): + """Calculate the parameter of interest for points given by (Y, T) and corresponding nuisance estimates. + + The parameter is calculated around the feature vector given by `X_single`. `X_single` can be used to do + local corrections on a preliminary parameter estimate. + """ # Compute partial moments pointwise_params = DiscreteTreatmentOrthoForest._partial_moments(Y, T, nuisance_estimates) X_aug = PolynomialFeatures(degree=1, include_bias=True).fit_transform(X) @@ -807,10 +880,13 @@ def parameter_estimator_func(Y, T, X, diagonal[0] = 0 reg = lambda_reg * np.diag(diagonal) # Ridge regression estimate - param_estimate = np.linalg.lstsq(np.matmul(weighted_X_aug.T, X_aug) + reg, - np.matmul(weighted_X_aug.T, pointwise_params), rcond=None)[0].flatten() - # Parameter returned by LinearRegression is (d_T, ) - return param_estimate + linear_coef_estimate = np.linalg.lstsq(np.matmul(weighted_X_aug.T, X_aug) + reg, + np.matmul(weighted_X_aug.T, pointwise_params), + rcond=None)[0].flatten() + X_aug = np.append([1], X_single) + linear_coef_estimate = linear_coef_estimate.reshape((X_aug.shape[0], -1)).T + # Parameter returned is of shape (d_T, ) + return np.dot(linear_coef_estimate, X_aug) return parameter_estimator_func @@ -855,3 +931,115 @@ def _check_treatment(self, T): except Exception as exc: raise ValueError("Expected numeric array but got non-numeric types.") return T + + +class BLBInference(Inference): + """ + Bootstrap-of-Little-Bags inference implementation for the OrthoForest classes. + + This class can only be used for inference with any estimator derived from :class:`BaseOrthoForest`. + + Parameters + ---------- + estimator : :class:`BaseOrthoForest` + Estimator to perform inference on. Must be a child class of :class:`BaseOrthoForest`. + """ + + def fit(self, estimator, *args, **kwargs): + """ + Fits the inference model. + + This is called after the estimator's fit. + """ + self._estimator = estimator + # Test whether the input estimator is supported + if not hasattr(self._estimator, "_pointwise_effect"): + raise TypeError("Unsupported estimator of type {}.".format(self._estimator.__class__.__name__) + + " Estimators must implement the '_pointwise_effect' method with the correct signature.") + # Test expansion of treatment + # If expanded treatments are a vector, flatten const_marginal_effect_interval + _, T0, _ = self._estimator._expand_treatments(None, 0, 1) + self._T_vec = (T0.ndim == 1) + return self + + def const_marginal_effect_interval(self, X=None, *, alpha=0.1): + """ Confidence intervals for the quantities :math:`\\theta(X)` produced + by the model. Available only when ``inference`` is ``blb``, when + calling the fit method. + + Parameters + ---------- + X: optional (m, d_x) matrix or None (Default=None) + Features for each sample + + alpha: optional float in [0, 1] (Default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + + Returns + ------- + lower, upper : tuple(type of :meth:`const_marginal_effect(X)` ,\ + type of :meth:`const_marginal_effect(X)` ) + The lower and the upper bounds of the confidence interval for each quantity. + """ + params_and_cov = self._predict_wrapper(X) + # Calculate confidence intervals for the parameter (marginal effect) + lower = alpha / 2 + upper = 1 - alpha / 2 + param_lower = [param + np.apply_along_axis(lambda s: norm.ppf(lower, scale=s), 0, np.sqrt(np.diag(cov_mat))) + for (param, cov_mat) in params_and_cov] + param_upper = [param + np.apply_along_axis(lambda s: norm.ppf(upper, scale=s), 0, np.sqrt(np.diag(cov_mat))) + for (param, cov_mat) in params_and_cov] + param_lower, param_upper = np.asarray(param_lower), np.asarray(param_upper) + if self._T_vec: + # If T is a vector, preserve shape of the effect interval + return param_lower.flatten(), param_upper.flatten() + return param_lower, param_upper + + def effect_interval(self, X=None, *, T0=0, T1=1, alpha=0.1): + """ Confidence intervals for the quantities :math:`\\tau(X, T0, T1)` produced + by the model. Available only when ``inference`` is ``blb``, when + calling the fit method. + + Parameters + ---------- + X: optional (m, d_x) matrix + Features for each sample + + T0: optional (m, d_t) matrix or vector of length m (Default=0) + Base treatments for each sample + + T1: optional (m, d_t) matrix or vector of length m (Default=1) + Target treatments for each sample + + alpha: optional float in [0, 1] (Default=0.1) + The overall level of confidence of the reported interval. + The alpha/2, 1-alpha/2 confidence interval is reported. + + Returns + ------- + lower, upper : tuple(type of :meth:`effect(X, T0, T1)`, type of :meth:`effect(X, T0, T1))` ) + The lower and the upper bounds of the confidence interval for each quantity. + """ + X, T0, T1 = self._estimator._expand_treatments(X, T0, T1) + dT = (T1 - T0) if T0.ndim == 2 else (T1 - T0).reshape(-1, 1) + params_and_cov = self._predict_wrapper(X) + # Calculate confidence intervals for the effect + lower = alpha / 2 + upper = 1 - alpha / 2 + # Calculate the effects + eff = np.asarray([np.dot(params_and_cov[i][0], dT[i]) for i in range(X.shape[0])]) + # Calculate the standard deviations for the effects + scales = [np.sqrt(dT[i] @ params_and_cov[i][1] @ dT[i]) for i in range(X.shape[0])] + effect_lower = eff + np.apply_along_axis(lambda s: norm.ppf(lower, scale=s), 0, scales) + effect_upper = eff + np.apply_along_axis(lambda s: norm.ppf(upper, scale=s), 0, scales) + return effect_lower, effect_upper + + def _predict_wrapper(self, X=None): + if not self._estimator.model_is_fitted: + raise NotFittedError('This {0} instance is not fitted yet.'.format(self._estimator.__class__.__name__)) + X = check_array(X) + # Get a list of (parameter, covariance matrix) pairs + params_and_cov = Parallel(n_jobs=self._estimator.n_jobs, verbose=3, backend='threading')( + delayed(self._estimator._pointwise_effect)(X_single, stderr=True) for X_single in X) + return params_and_cov diff --git a/econml/tests/test_orf.py b/econml/tests/test_orf.py index 86a24da65..114062a2b 100644 --- a/econml/tests/test_orf.py +++ b/econml/tests/test_orf.py @@ -40,7 +40,6 @@ def setUpClass(cls): # Remove warnings that might be raised by the models passed into the ORF warnings.filterwarnings("ignore") - @pytest.mark.slow def test_continuous_treatments(self): np.random.seed(123) # Generate data with continuous treatments @@ -64,7 +63,7 @@ def test_continuous_treatments(self): TestOrthoForest.X, TestOrthoForest.W) # Check that outputs have the correct shape out_te = est.const_marginal_effect(TestOrthoForest.x_test) - self.assertSequenceEqual((TestOrthoForest.x_test.shape[0], 1), out_te.shape) + self.assertEqual(TestOrthoForest.x_test.shape[0], out_te.shape[0]) # Test continuous treatments with controls est = ContinuousTreatmentOrthoForest(n_trees=50, min_leaf_size=10, max_depth=50, subsample_ratio=0.30, bootstrap=False, n_jobs=4, @@ -72,15 +71,16 @@ def test_continuous_treatments(self): model_Y=Lasso(alpha=0.024), model_T_final=WeightedLassoCVWrapper(), model_Y_final=WeightedLassoCVWrapper()) - est.fit(Y, T, TestOrthoForest.X, TestOrthoForest.W) + est.fit(Y, T, TestOrthoForest.X, TestOrthoForest.W, inference="blb") self._test_te(est, TestOrthoForest.expected_exp_te, tol=0.5) + self._test_ci(est, TestOrthoForest.expected_exp_te, tol=1.5) # Test continuous treatments without controls T = TestOrthoForest.eta_sample(TestOrthoForest.n) Y = T * TE + TestOrthoForest.epsilon_sample(TestOrthoForest.n) - est.fit(Y, T, TestOrthoForest.X) + est.fit(Y, T, TestOrthoForest.X, inference="blb") self._test_te(est, TestOrthoForest.expected_exp_te, tol=0.5) + self._test_ci(est, TestOrthoForest.expected_exp_te, tol=1.5) - @pytest.mark.slow def test_binary_treatments(self): np.random.seed(123) # Generate data with binary treatments @@ -117,21 +117,23 @@ def test_binary_treatments(self): # Test binary treatments with controls est = DiscreteTreatmentOrthoForest(n_trees=100, min_leaf_size=10, max_depth=30, subsample_ratio=0.30, bootstrap=False, n_jobs=4, - propensity_model=LogisticRegression(C=1 / 0.024, penalty='l1'), + propensity_model=LogisticRegression( + C=1 / 0.024, penalty='l1', solver='saga'), model_Y=Lasso(alpha=0.024), propensity_model_final=LogisticRegressionCV(penalty='l1', solver='saga'), model_Y_final=WeightedLassoCVWrapper()) - est.fit(Y, T, TestOrthoForest.X, TestOrthoForest.W) + est.fit(Y, T, TestOrthoForest.X, TestOrthoForest.W, inference="blb") self._test_te(est, TestOrthoForest.expected_exp_te, tol=0.7, treatment_type='discrete') + self._test_ci(est, TestOrthoForest.expected_exp_te, tol=1.5, treatment_type='discrete') # Test binary treatments without controls log_odds = TestOrthoForest.eta_sample(TestOrthoForest.n) T_sigmoid = 1 / (1 + np.exp(-log_odds)) T = np.array([np.random.binomial(1, p) for p in T_sigmoid]) Y = T * TE + TestOrthoForest.epsilon_sample(TestOrthoForest.n) - est.fit(Y, T, TestOrthoForest.X) + est.fit(Y, T, TestOrthoForest.X, inference="blb") self._test_te(est, TestOrthoForest.expected_exp_te, tol=0.5, treatment_type='discrete') + self._test_ci(est, TestOrthoForest.expected_exp_te, tol=1.5, treatment_type='discrete') - @pytest.mark.slow def test_multiple_treatments(self): np.random.seed(123) # Only applicable to continuous treatments @@ -150,9 +152,10 @@ def test_multiple_treatments(self): model_Y=Lasso(alpha=0.024), model_T_final=WeightedLassoCVWrapper(), model_Y_final=WeightedLassoCVWrapper()) - est.fit(Y, T, TestOrthoForest.X, TestOrthoForest.W) + est.fit(Y, T, TestOrthoForest.X, TestOrthoForest.W, inference="blb") expected_te = np.array([TestOrthoForest.expected_exp_te, TestOrthoForest.expected_const_te]).T self._test_te(est, expected_te, tol=0.5, treatment_type='multi') + self._test_ci(est, expected_te, tol=2.0, treatment_type='multi') def test_effect_shape(self): import scipy.special @@ -206,7 +209,7 @@ def _test_te(self, learner_instance, expected_te, tol, treatment_type='continuou ) # Compute treatment effect residuals if treatment_type == 'continuous': - te_res = np.abs(expected_te - te_hat[:, 0]) + te_res = np.abs(expected_te - te_hat) elif treatment_type == 'discrete': te_res = np.abs(expected_te - te_hat[:, 0]) else: @@ -215,6 +218,29 @@ def _test_te(self, learner_instance, expected_te, tol, treatment_type='continuou # Allow at most 10% test points to be outside of the tolerance interval self.assertLessEqual(np.mean(te_res > tol), 0.1) + def _test_ci(self, learner_instance, expected_te, tol, treatment_type='continuous'): + # Compute the treatment effect on test points + te_lower, te_upper = learner_instance.const_marginal_effect_interval( + TestOrthoForest.x_test + ) + # Compute treatment effect residuals + if treatment_type == 'continuous': + delta_ci_upper = te_upper - expected_te + delta_ci_lower = expected_te - te_lower + elif treatment_type == 'discrete': + delta_ci_upper = te_upper[:, 0] - expected_te + delta_ci_lower = expected_te - te_lower[:, 0] + else: + # Multiple treatments + delta_ci_upper = te_upper - expected_te + delta_ci_lower = expected_te - te_lower + # Allow at most 20% test points to be outside of the confidence interval + # Check that the intervals are not too wide + self.assertLessEqual(np.mean(delta_ci_upper < 0), 0.2) + self.assertLessEqual(np.mean(np.abs(delta_ci_upper) > tol), 0.2) + self.assertLessEqual(np.mean(delta_ci_lower < 0), 0.2) + self.assertLessEqual(np.mean(np.abs(delta_ci_lower) > tol), 0.2) + @classmethod def _const_te(cls, x): return 2 diff --git a/notebooks/Orthogonal Random Forest Examples.ipynb b/notebooks/Orthogonal Random Forest Examples.ipynb index 695234ee0..5415c7733 100644 --- a/notebooks/Orthogonal Random Forest Examples.ipynb +++ b/notebooks/Orthogonal Random Forest Examples.ipynb @@ -23,7 +23,7 @@ "\n", "Orthogonal Random Forest (ORF) combines orthogonalization,\n", "a technique that effectively removes the confounding effect in two-stage estimation,\n", - "with generalized random forests, a flexible method for estimating treatment effect heterogeneity. Due to the orthogonalization aspect of this method, the ORF performs especially well in the presence of high-dimensional confounders. For more details, see [this paper](https://arxiv.org/abs/1806.03467).\n", + "with generalized random forests, a flexible method for estimating treatment effect heterogeneity. Due to the orthogonalization aspect of this method, the ORF performs especially well in the presence of high-dimensional confounders. For more details, see [this paper](https://arxiv.org/abs/1806.03467) or the [EconML docummentation](https://econml.azurewebsites.net/).\n", "\n", "The EconML SDK implements the following OrthoForest variants:\n", "\n", @@ -31,17 +31,14 @@ "\n", "* DiscreteTreatmentOrthoForest: suitable for discrete treatments\n", "\n", - "In this notebook, we show the performance of the ORF on synthetic data.\n", + "In this notebook, we show the performance of the ORF on synthetic and observational data. \n", "\n", - "**Notebook contents:**\n", + "## Notebook Contents\n", "\n", - "1. Example usage with continuous treatment synthetic data\n", - "\n", - "2. Example usage with binary treatment synthetic data\n", - "\n", - "3. Example usage with multiple discrete treatment synthetic data\n", - "\n", - "4. Example usage with real continuous treatment observational data" + "1. [Example Usage with Continuous Treatment Synthetic Data](#1.-Example-Usage-with-Continuous-Treatment-Synthetic-Data)\n", + "2. [Example Usage with Binary Treatment Synthetic Data](#2.-Example-Usage-with-Binary-Treatment-Synthetic-Data)\n", + "3. [Example Usage with Multiple Treatment Synthetic Data](#3.-Example-Usage-with-Multiple-Treatment-Synthetic-Data)\n", + "4. [Example Usage with Real Continuous Treatment Observational Data](#4.-Example-Usage-with-Real-Continuous-Treatment-Observational-Data)" ] }, { @@ -50,7 +47,9 @@ "metadata": {}, "outputs": [], "source": [ - "import econml" + "import econml\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" ] }, { @@ -76,14 +75,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1. Example Usage with Continuous Treatment Synthetic Data" + "# 1. Example Usage with Continuous Treatment Synthetic Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 1.1. DGP \n", + "## 1.1 DGP \n", "We use the data generating process (DGP) from [here](https://arxiv.org/abs/1806.03467). The DGP is described by the following equations:\n", "\n", "\\begin{align}\n", @@ -142,9 +141,7 @@ "Y = TE * T + np.dot(W[:, support_Y], coefs_Y) + epsilon_sample(n)\n", "\n", "# ORF parameters and test data\n", - "# The following parameters are set according to theory\n", - "subsample_power = 0.88\n", - "subsample_ratio = ((n/np.log(n_w))**(subsample_power)) / n\n", + "subsample_ratio = 0.3\n", "lambda_reg = np.sqrt(np.log(n_w) / (10 * subsample_ratio * n))\n", "X_test = np.array(list(product(np.arange(0, 1, 0.01), repeat=n_x)))" ] @@ -153,13 +150,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 1.2. Train Estimator\n", + "## 1.2. Train Estimator\n", "\n", "**Note:** The models in the final stage of the estimation (``model_T_final``, ``model_Y_final``) need to support sample weighting. \n", "\n", - "If the models of choice do not support sample weights (e.g. ``sklearn.linear_model.LassoCV``), the ``econml`` packages provides a convenient wrapper for these models ``WeightedModelWrapper`` in order to allow sample weights. \n", - "\n", - "If the model of choice is a linear (regression) model such as Lasso, you should set ``sample_type=\"weighted\"``. Otherwise, set ``sample_type=\"sampled\"``." + "If the models of choice do not support sample weights (e.g. ``sklearn.linear_model.LassoCV``), the ``econml`` packages provides a convenient wrapper for these models ``WeightedModelWrapper`` in order to allow sample weights." ] }, { @@ -170,14 +165,21 @@ "source": [ "est = ContinuousTreatmentOrthoForest(\n", " n_trees=200, min_leaf_size=5,\n", - " max_depth=50, subsample_ratio=2*subsample_ratio, bootstrap=False, \n", + " max_depth=50, subsample_ratio=subsample_ratio,\n", " model_T=Lasso(alpha=lambda_reg),\n", " model_Y=Lasso(alpha=lambda_reg),\n", - " model_T_final=WeightedLasso(alpha=lambda_reg), \n", + " model_T_final=WeightedLasso(alpha=lambda_reg),\n", " model_Y_final=WeightedLasso(alpha=lambda_reg),\n", " random_state=123)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To use the built-in confidence intervals constructed via Bootstrap of Little Bags, we need to specify `inference=\"blb\"` at `fit` time." + ] + }, { "cell_type": "code", "execution_count": 6, @@ -188,19 +190,18 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 4.3s\n", - "[Parallel(n_jobs=-1)]: Done 185 out of 200 | elapsed: 5.8s remaining: 0.4s\n", - "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 5.8s finished\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 6.0s\n", + "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 7.7s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.1s\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.2s\n", "[Parallel(n_jobs=-1)]: Done 118 out of 200 | elapsed: 1.0s remaining: 0.7s\n", - "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 1.4s finished\n" + "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 1.5s finished\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -209,7 +210,7 @@ } ], "source": [ - "est.fit(Y, T, X, W)" + "est.fit(Y, T, X, W, inference=\"blb\")" ] }, { @@ -222,30 +223,51 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.4s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 2.2s finished\n" + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", + "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.4s finished\n" ] } ], "source": [ + "# Calculate treatment effects\n", "treatment_effects = est.effect(X_test)" ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 1.1s\n", + "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 6.4s finished\n" + ] + } + ], + "source": [ + "# Calculate default (90%) confidence intervals for the test data\n", + "te_lower, te_upper = est.effect_interval(X_test)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 1.3. Performance Visualization" + "## 1.3. Performance Visualization" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -257,10 +279,10 @@ } ], "source": [ - "y = treatment_effects[:, 0]\n", - "plt.plot(X_test, y, label='ORF estimate')\n", + "plt.plot(X_test, treatment_effects, label='ORF estimate')\n", "expected_te = np.array([exp_te(x_i) for x_i in X_test])\n", "plt.plot(X_test[:, 0], expected_te, 'b--', label='True effect')\n", + "plt.fill_between(X_test[:, 0], te_lower, te_upper, label=\"90% BLB CI\", alpha=0.3)\n", "plt.ylabel(\"Treatment Effect\")\n", "plt.xlabel(\"x\")\n", "plt.legend()\n", @@ -271,14 +293,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2. Example Usage with Binary Treatment Synthetic Data" + "# 2. Example Usage with Binary Treatment Synthetic Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 2.1. DGP \n", + "## 2.1. DGP \n", "We use the following DGP:\n", "\n", "\\begin{align}\n", @@ -298,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -330,10 +352,7 @@ "Y = TE * T + np.dot(W[:, support_Y], coefs_Y) + epsilon_sample(n)\n", "\n", "# ORF parameters and test data\n", - "# The following parameters are set according to theory\n", - "subsample_power = 0.88\n", - "subsample_ratio = ((n/np.log(n_w))**(subsample_power)) / n\n", - "lambda_reg = np.sqrt(np.log(n_w) / (10 * subsample_ratio * n))\n", + "subsample_ratio = 0.4\n", "X_test = np.array(list(product(np.arange(0, 1, 0.01), repeat=n_x)))" ] }, @@ -341,18 +360,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 2.2. Train Estimator " + "## 2.2. Train Estimator " ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "est = DiscreteTreatmentOrthoForest(\n", " n_trees=200, min_leaf_size=10,\n", - " max_depth=30, subsample_ratio=2*subsample_ratio, bootstrap=False,\n", + " max_depth=30, subsample_ratio=subsample_ratio,\n", " propensity_model = LogisticRegression(C=1/(X.shape[0]*lambda_reg), penalty='l1', solver='saga'),\n", " model_Y = Lasso(alpha=lambda_reg),\n", " propensity_model_final=LogisticRegression(C=1/(X.shape[0]*lambda_reg), penalty='l1', solver='saga'), \n", @@ -362,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -370,32 +389,31 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.1s\n", - "[Parallel(n_jobs=-1)]: Done 118 out of 200 | elapsed: 0.8s remaining: 0.5s\n", - "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 1.2s finished\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 1.4s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.1s\n", - "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 1.1s finished\n" + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=-1)]: Done 200 out of 200 | elapsed: 1.5s finished\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "est.fit(Y, T, X, W)" + "est.fit(Y, T, X, W, inference=\"blb\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -403,30 +421,51 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.4s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.2s finished\n" + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", + "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.7s finished\n" ] } ], "source": [ + "# Calculate treatment effects for the default treatment points T0=0 and T1=1\n", "treatment_effects = est.effect(X_test)" ] }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 1.1s\n", + "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 6.8s finished\n" + ] + } + ], + "source": [ + "# Calculate default (90%) confidence intervals for the default treatment points T0=0 and T1=1\n", + "te_lower, te_upper = est.effect_interval(X_test)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 2.3. Performance Visualization" + "## 2.3. Performance Visualization" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -438,10 +477,12 @@ } ], "source": [ + "# Smaller slices\n", "y = treatment_effects\n", "plt.plot(X_test, y, label='ORF estimate')\n", "expected_te = np.array([exp_te(x_i) for x_i in X_test])\n", "plt.plot(X_test[:, 0], expected_te, 'b--', label='True effect')\n", + "plt.fill_between(X_test[:, 0], te_lower, te_upper, label=\"90% BLB CI\", alpha=0.3)\n", "plt.ylabel(\"Treatment Effect\")\n", "plt.xlabel(\"x\")\n", "plt.legend()\n", @@ -452,14 +493,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 3. Example Usage with Multiple Treatment Synthetic Data" + "# 3. Example Usage with Multiple Treatment Synthetic Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.1 DGP \n", + "## 3.1. DGP \n", "We use the following DGP:\n", "\n", "\\begin{align}\n", @@ -480,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -511,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -520,19 +561,19 @@ " return [np.exp(2*x[0]), 3*scipy.special.expit(100*(x[0] - .5)) - 1, -2*scipy.special.expit(100*(x[0] - .25))]\n", "\n", "np.random.seed(123)\n", - "(Y, T, X, W), (X_test, te_test) = get_test_train_data(1000, 3, 3, 1, te_func, 4)" + "(Y, T, X, W), (X_test, te_test) = get_test_train_data(2000, 3, 3, 1, te_func, 4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.2 Train Estimator" + "## 3.2. Train Estimator" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -542,7 +583,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -550,34 +591,35 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.3s\n", - "[Parallel(n_jobs=-1)]: Done 208 tasks | elapsed: 3.7s\n", - "[Parallel(n_jobs=-1)]: Done 500 out of 500 | elapsed: 9.1s finished\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.5s\n", + "[Parallel(n_jobs=-1)]: Done 112 tasks | elapsed: 4.1s\n", + "[Parallel(n_jobs=-1)]: Done 272 tasks | elapsed: 10.6s\n", + "[Parallel(n_jobs=-1)]: Done 500 out of 500 | elapsed: 19.5s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.4s\n", - "[Parallel(n_jobs=-1)]: Done 112 tasks | elapsed: 2.2s\n", - "[Parallel(n_jobs=-1)]: Done 272 tasks | elapsed: 5.4s\n", - "[Parallel(n_jobs=-1)]: Done 500 out of 500 | elapsed: 9.9s finished\n" + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.8s\n", + "[Parallel(n_jobs=-1)]: Done 112 tasks | elapsed: 4.0s\n", + "[Parallel(n_jobs=-1)]: Done 272 tasks | elapsed: 9.3s\n", + "[Parallel(n_jobs=-1)]: Done 500 out of 500 | elapsed: 20.2s finished\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "est.fit(Y, T, X, W)" + "est.fit(Y, T, X, W, inference=\"blb\")" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -585,30 +627,51 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.9s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 5.1s finished\n" + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 1.7s\n", + "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 9.6s finished\n" ] } ], "source": [ + "# Calculate marginal treatment effects\n", "treatment_effects = est.const_marginal_effect(X_test)" ] }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 3.0s\n", + "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 15.8s finished\n" + ] + } + ], + "source": [ + "# Calculate default (90%) marginal confidence intervals for the test data\n", + "te_lower, te_upper = est.const_marginal_effect_interval(X_test)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.3 Performance Visualization" + "## 3.3. Performance Visualization" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -621,9 +684,11 @@ ], "source": [ "y = treatment_effects\n", + "colors = ['b', 'r', 'g']\n", "for it in range(y.shape[1]):\n", - " plt.plot(X_test, y[:, it], label='ORF estimate T={}'.format(it))\n", - " plt.plot(X_test[:, 0], te_test[:, it], '--', label='True effect T={}'.format(it))\n", + " plt.plot(X_test[:, 0], te_test[:, it], '--', label='True effect T={}'.format(it), color=colors[it])\n", + " plt.fill_between(X_test[:, 0], te_lower[:, it], te_upper[:, it], alpha=0.3, color='C{}'.format(it))\n", + " plt.plot(X_test, y[:, it], label='ORF estimate T={}'.format(it), color='C{}'.format(it))\n", "plt.ylabel(\"Treatment Effect\")\n", "plt.xlabel(\"x\")\n", "plt.legend()\n", @@ -634,7 +699,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 4. Example usage with real continuous treatment observational data\n", + "# 4. Example Usage with Real Continuous Treatment Observational Data\n", "\n", "We applied our technique to Dominick’s dataset, a popular historical dataset of store-level orange juice prices and sales provided by University of Chicago Booth School of Business. \n", "\n", @@ -649,12 +714,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.1. Data" + "## 4.1. Data" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -667,16 +732,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading file (this might take a few seconds)...\n" - ] - }, { "data": { "text/html": [ @@ -845,7 +903,7 @@ "4 0.376927 " ] }, - "execution_count": 21, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -863,7 +921,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -881,32 +939,31 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.2. Train Estimator" + "## 4.2. Train Estimator" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# Define some parameters\n", - "n_trees = 2000\n", + "n_trees = 1000\n", "min_leaf_size = 50\n", "max_depth = 20\n", - "subsample_ratio = 0.02\n", - "bootstrap = False" + "subsample_ratio = 0.04" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "est = ContinuousTreatmentOrthoForest(\n", " n_trees=n_trees, min_leaf_size=min_leaf_size, max_depth=max_depth, \n", - " subsample_ratio=subsample_ratio, bootstrap=bootstrap, \n", + " subsample_ratio=subsample_ratio,\n", " model_T=Lasso(alpha=0.1),\n", " model_Y=Lasso(alpha=0.1),\n", " model_T_final=WeightedLassoCVWrapper(cv=3), \n", @@ -916,7 +973,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "metadata": { "scrolled": true }, @@ -926,31 +983,31 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 296 tasks | elapsed: 0.5s\n", - "[Parallel(n_jobs=-1)]: Done 2000 out of 2000 | elapsed: 2.2s finished\n", + "[Parallel(n_jobs=-1)]: Done 232 tasks | elapsed: 0.5s\n", + "[Parallel(n_jobs=-1)]: Done 1000 out of 1000 | elapsed: 2.1s finished\n", "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.1s\n", - "[Parallel(n_jobs=-1)]: Done 2000 out of 2000 | elapsed: 2.3s finished\n" + "[Parallel(n_jobs=-1)]: Done 232 tasks | elapsed: 0.5s\n", + "[Parallel(n_jobs=-1)]: Done 1000 out of 1000 | elapsed: 1.9s finished\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 25, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "est.fit(Y, T, X, W)" + "est.fit(Y, T, X, W, inference=\"blb\")" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -962,7 +1019,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -970,46 +1027,51 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 41.0s\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "285.2490632534027\n" + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 8.7s\n", + "[Parallel(n_jobs=-1)]: Done 101 out of 101 | elapsed: 1.0min finished\n" ] - }, + } + ], + "source": [ + "# Calculate marginal treatment effects\n", + "treatment_effects = est.const_marginal_effect(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=-1)]: Done 101 out of 101 | elapsed: 4.8min finished\n" + "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", + "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 12.0s\n", + "[Parallel(n_jobs=-1)]: Done 101 out of 101 | elapsed: 1.3min finished\n" ] } ], "source": [ - "import time\n", - "t0 = time.time()\n", - "te_pred = est.const_marginal_effect(X_test)\n", - "print(time.time() - t0)" + "# Calculate default (90%) marginal confidence intervals for the test data\n", + "te_upper, te_lower = est.const_marginal_effect_interval(X_test)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.3. Performance Visualization" + "## 4.3. Performance Visualization" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEaCAYAAAA2f6EIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xl8FeXd///XOwlJ2AIkAWQngBubqBFo3aqoVYqi1lpbV7Q3tXftZr1vS2nv297V3q3aqnf9/mqtrWKrba2V2lq1oKK2VlBACigoyiIJW0ggLCGQ5fP7YybxEM5JTpJzcrJ8no/HeeTMzDUzn0lO5nPmumauS2aGc84511ppqQ7AOedc5+AJxTnnXEJ4QnHOOZcQnlCcc84lhCcU55xzCeEJxTnnXEJ4QnFdgqTTJb3bxvt8RNLtSdjuA5K+G0e55yRdm+j9OxeLJ5QuTtJ1klZJqpC0TdLPJPVNdVzxCGP/RzxlzezvZnZsgvc/UpJJ2tfg9dkE7uOIYzSzG83s+02ta2YXmNm8WNtpa5I+IakolTG45PKE0oVJ+ibwI+A/gD7AVGAEsFBSZox1Mtouwg6jr5n1inj9PtUBOZcKnlC6KEk5wPeAr5jZ82ZWZWYbgcsJkspVYbnbJD0p6TeS9gDXSZos6XVJuyVtlXR/ZAIKv7XfKGmdpF2S/p8khcvSJf1Y0k5JGyTdFJbPCJf3kfTLcLvFkm6XlB7nMZmkMRHT9VVODb8dSxom6SlJJZJKJd0fsex6SWvC2P8maUSLf9EfbbOfpGfC/e0K3w+NWH6dpPWS9oa/lyslHQ88AHwsvPLZ3fC4wumZklZI2iPpA0nnh/NflvSFaNuRdIqk7ZFfECR9WtKKKLFPDa9e0yPmXSJpZfh+sqSl4f63S/pJnL+TlyV9X9Jr4XEvkJQfsfw0Sf8M490s6bpwfh9Jj4a/y02SviMpLeL3+Jqke8L11kv6eDh/s6QdiqgGlJQl6W5JH4axPyCpezzxuyN5Qum6Pg5kA09FzjSzfcBzwLkRs2cCTwJ9gceAGuAbQD7wMWAa8O8Ntj8DOAU4gSBJfTKc/2/ABcAk4CTg4gbrzQOqgTHAicB5wBdadojRhSfGZ4BNwEhgCPC7cNnFwLeBS4H+wN+B3yZgt2nAwwTJejhwALg/3GdP4P+AC8ysN8HfZoWZrQFuBF4Pr3yOqIqUNBl4lOAqsy9wBrAxsky07ZjZm0Aph/+drwJ+3XAfZrYY2A+cHTH788Dj4fv7gPvMLAcYDTwR5++kbjuzgAFAJnBLeFzDCT6HPyX4O0wC6pLdTwmuqEcBZwLXhNuoMwVYCeSFMf6O4LM4JjzG+yX1Csv+CDgm3P4Ygs/CfzUjfhfBE0rXlQ/sNLPqKMu2hsvrvG5mfzKzWjM7YGbLzGyxmVWHVzU/J/jHjvRDM9ttZh8Ciwj+YSFILveZWZGZ7QJ+WLeCpIEEyebrZrbfzHYA9wBXJOB4I00GBgP/Ee6n0szq2he+CPyvma0Jfzc/ACY1cZWyM/w2XPc6vmEBMys1sz+aWYWZ7QXu4PDfWS0wXlJ3M9tqZm/HeSw3AL8ys4Xh36fYzNbGue48ProSzSVI+o/HKPtb4HNh2d7AdD5KtFXAGEn5ZrYvTEDxetjM3jOzAwSJqO5zciXwgpn9Nrx6LjWzFeGXgc8Cc8xsb/j5+zFwdcQ2N5jZw2ZWA/weGAb8j5kdNLMFwKEwXhF8wfmGmZWFf5cfkPjPW5fhCaXr2gnkK3qbyKBweZ3NkQslHRNW2WxTUA32Aw5PQADbIt5XAHXfCAc32F7k+xFAN2Br3cmZIFkNiPOY4jUM2BQjmY4A7ovYfxkggm+useSH3/rrXmsaFpDUQ9LPwyqaPcCrQF9J6Wa2n+AkeSPBsf9V0nHNOJYP4izb0G+AC8Nv65cDfzezrTHKPg5cKimL4OptuZltCpfdQPAtf62kNyXNaEYMsT4nsY4rn+BKZlPEvE0c/vfZHvH+AICZNZzXi+DKpwewLOLv/Xw437WAJ5Su63XgIMHJoV5Y/XIB8GLE7IZdUv8MWAscHVZzfJvgpBuPrcDQiOlhEe83hzFFnqBzzGxcnNuuIDhB1DkqRrnNwPAYyXQz8MUGCaK7mf0zzhhi+SZwLDAl/J2dEc4XgJn9zczOJUjma4FfhMub6g58M0E1U1OO2I6ZFRN8Di4h+IZ/RHVXRNl3CE7cF3B4dRdmts7MPkeQ+H8EPBl+jloj1nHtJLgiirxiHA4Ut2AfOwmSy7iIv3UfM+vV1IouOk8oXZSZlRM0yv9U0vmSukkaCfwBKKKRkwvQG9gD7Au/SX+pGbt+AviapCEKbk++NSKmrcAC4MeSciSlSRotqWF1WiwrgM8raPg/nyOr4eq8QZDYfiipp6RsSaeGyx4A5kgaB/UNwJ9pxvHF0pvg5LU7rF7677oFkgZKuig8CR8E9hG0U0HwbXuoYtx1B/wSmCVpWvj7GhLj6ibWdh4F/hOYAMxv4hgeB75KkAz/EBH/VZL6m1ktsDucXRNl/eZ4DDhH0uWSMiTlSZoUVmM9AdwhqXdYFXkzwdVWs4Tx/gK4R9KA8FiGSPpk42u6WDyhdGFmdifB1cXdBAliCcE3w2lmdrCRVW8h+Ja6l+Afsjm3yf6CIGmsBN4CniVohK87AV1DUKXxDrCL4GaAQY0dRsT7rwEXEpzUrgT+FHWF4KR0IUEj7IcECfSz4bL5BN+yfxdWTa0m+FbemN06/DmUm6OUuRfoTvCteDFB1UqdNIIrmC0EVWxn8tFNDi8BbwPbJEVWQ9YdyxsEDdL3AOXAKxz+7b1OrO3MD8vPD6veGvNb4BPAS2YWuY3zgbcl7SNooL/CzCqb2Fajwra36QS/lzKCLwsnhIu/QnCTwHrgHwSJ7lct3NWtwPvA4vDv/QLBlaRrAfkAWy6VJF0APGBmzb41V9JXgbPNrOGdYq4ZJH1AUM33QqpjcR2bX6G4NiWpu6TpYTXGEIKqn6aqWqJtJ5vgdualiY6xK5H0aYKrvJdSHYvr+DyhuLYmgrabXQRVXmto5n3/kiYQ3B20h/BZDtd8kl4muMHiy2F7gnOt4lVezjnnEsKvUJxzziVEl+roLz8/30aOHJnqMJxzrkNZtmzZTjNr8oHPLpVQRo4cydKl3obrnHPNIWlT06VSWOUl6S5JayWtlDRfjYzBET6o9pakZyLmFUhaoqBH29838uCXc865NpDKNpSFwHgzmwi8B8xppOzXCO4GivQj4B4zO5rgjqEbkhKlc865uKQsoZjZgojO+RZzeP9O9RSMGfEp4KGIeSLoSvvJcNY8juwG3TnnXBtqL20o1xO7+457Cfoa6h0xLw/YHZGQiojRG6yk2cBsgOHDhx+xvKqqiqKiIiorW9VThGum7Oxshg4dSrdu3VIdinMuQZKaUCS9QPQeX+ea2dNhmbkEfTk9FmX9GcAOM1sm6RORi6JsM+oDNWb2IPAgQGFh4RFlioqK6N27NyNHjiS48HHJZmaUlpZSVFREQUFBqsNxziVIUhOKmZ3T2HIFQ3HOIOiMMFpCOBW4SNJ0gtEFcyT9hqCr7b6SMsKrlKEEHes1W2VlpSeTNiaJvLw8SkpKUh2Kcy6BUnmX1/kEPX1eZGYV0cqY2RwzG2pmIwlGUXvJzK4Kk88i4LKw6LXA062IpaWruhby37lznU8q21DuB7KAheHJZbGZ3ShpMPCQmU1vYv1bCboYv52gT6hfJjVa55xLsdpao7K6hsqqWg5U1VBZ/6rlYFUNldU1HDhUG8wLy1VW1XCwqoZLTxrKyPzWjnvWuJQlFDMbE2P+FoJxEBrOfxl4OWJ6PcHY4B1eUVERX/7yl3nnnXeora1lxowZ3HXXXWRmZvLyyy9z991388wzzxy2zssvv8zMmTMPa4O4++67Oeecc+jVqxf79u1rdhz33nsvs2fPpkePYNDD6dOn8/jjj9O3b/RHhB544AF69OjBNddcwyOPPMJ5553H4MGDm71f5zqqmlr76KReXdusE3xldS0HDn207oFDNRys/mj9I9ep5VBNy/rwlOCkEf06b0JxATPj0ksv5Utf+hJPP/00NTU1zJ49m7lz53LXXXc1uu7pp59+RKJpjXvvvZerrrqqPqE8++yzjZa/8cYb698/8sgjjB8/3hOKS6m6E/yBqsNPzAcjTszRTtaVDcofqEsK1cGJPEgMiT3BZ2ekk90tjexu6WR3Sycro+59Gnm9Mukezs/ulkZWRvC+e7fIddLC9Q7fTna3tI/WzUgnq1saWRlpbVLN7AklxV566SWys7OZNWsWAOnp6dxzzz0UFBTwve99r1Xb3rdvHzNnzmTXrl1UVVVx++23M3PmTPbv38/ll19OUVERNTU1fPe732X79u1s2bKFs846i/z8fBYtWlTfVU1+fj6PPvood999N5KYOHEiv/71r7ntttvo1atXfbkrr7yS7t27c8cdd/DQQw8xf34wzMnChQv52c9+xlNPPdXq35frPA4cqmHfwWr2H6ym4lBwEj9YFcwr2XeQHXsOUrb/UDC/OvqJv/4EH57sq2pa3nv6YSfihif4nplk900/7ERed8Ju7AQfmRTqy2emkZneNif4tuYJJcL3/vI272zZk9Btjh2cw39fOC7m8rfffpuTTz75sHk5OTkMHz6c999/v9Ft//3vf2fSpEn103/84x8ZPXp0/XR2djbz588nJyeHnTt3MnXqVC666CKef/55Bg8ezF//+lcAysvL6dOnDz/5yU9YtGgR+fn5R8R4xx138Nprr5Gfn09ZWdlhyy+77DLuv/9+7r77bgoLCzEzvvnNb1JSUkL//v15+OGH6xOm69re37GPZ1dt5a8rt/Lu9r1Nlu/TvRs9Mj86wXfPDE7K+b0yDvtGXvcN/vCkEPmtPZ3sjMO/xafiG3xn5wklxcws6gc51vxITVV5mRnf/va3efXVV0lLS6O4uJjt27czYcIEbrnlFm699VZmzJjB6aef3uh+XnrpJS677LL6RJObm9toeUlcffXV/OY3v2HWrFm8/vrrPProo42u4zo3M+O2P7/NvNc3IcEpI3K55bxj6NMjk56Z6fTIzKg/yffMzKB/7yzyemXSLd1H2OhIPKFEaOxKIlnGjRvHH//4x8Pm7dmzh82bNzN69GhKS0tbvO3HHnuMkpISli1bRrdu3Rg5ciSVlZUcc8wxLFu2jGeffZY5c+Zw3nnn8V//FXvQxHiSW0OzZs3iwgsvJDs7m8985jNkZPhHrSv75T82MO/1TVw1dTg3nXU0R/XJTnVILgk8/afYtGnTqKioqP8GX1NTwze/+U2uu+66+sbxliovL2fAgAF069aNRYsWsWlT0AP1li1b6NGjB1dddRW33HILy5cvB6B3797s3XtkNcS0adN44okn6pNbwyqvaOsOHjyYwYMHc/vtt3Pddde16jhcx/bCO9u549k1XDD+KP7novGeTDoxTygpJon58+fzhz/8gaOPPppjjjmG7OxsfvCDHwBQXV1NVlZW1HXr2lDqXk8++eRhy6+88kqWLl1KYWEhjz32GMcddxwAq1atYvLkyUyaNIk77riD73znOwDMnj2bCy64gLPOOuuw7YwbN465c+dy5plncsIJJ3DzzTcfEct1113HjTfeyKRJkzhw4ED9/ocNG8bYsWNb90tyHdaarXv46u/eYvzgPvzk8kmkpXk7RWfWpcaULywstIYDbK1Zs4bjjz8+RRE17b777qO4uJg777wz1aE020033cSJJ57IDTdEH1mgvf/uXevd9PhyXnt/J89//QwG5viVSUclaZmZFTZVziu227EbbriB1atX88QTT6Q6lGY7+eST6dmzJz/+8Y9THYpLoZVF5Xx8dL4nky7CE0o79stfdtzeZJYtW5bqEFyK7a44xIdlFXx+ypHDRrjOydtQCO5icm3Lf+ed38qicgAmDumT4khcW+nyCSU7O5vS0lI/wbWhuvFQsrO9GqQzW1UcJJRxnlC6jC5f5TV06FCKiop8bI42Vjdio+u8VhbtpiC/J326+6icXUWXTyjdunXzUQOdS4JVReUUjmy8VwXXuXT5Ki/nXOKV7D3IlvJKJg716q6uxBOKcy7hVoftJxO8/aRLSUlCkXSXpLWSVkqaLyn6CE5B2XRJb0l6JmLeI5I2SFoRvibFWt851/ZWFpUjeYN8V5OqK5SFwHgzmwi8B8xppOzXgDVR5v+HmU0KXyuSEaRzrmVWFu1mdP9e9Mrq8s20XUpKEoqZLTCz6nByMRD1dh9JQ4FPAQ+1VWzOudYxM1YWl/vzJ11Qe2hDuR54Lsaye4H/BKKNs3lHWGV2j6TovScCkmZLWippqd8a7Fzybd9zkJK9B5ngDfJdTtISiqQXJK2O8poZUWYuUA08FmX9GcAOM4vWh8cc4DjgFCAXuDVWHGb2oJkVmllh//79W3tYzrkmrCzaDeB3eHVBSavgNLNzGlsu6VpgBjDNoj+mfipwkaTpQDaQI+k3ZnaVmW0NyxyU9DBwSyJjd841j5lRtv8QG0sreGblVtLTxNhBnlC6mpS0mEk6n+Cq4kwzq4hWxszmEDbWS/oEcIuZXRVODzKzrQqGEbwYWN0mgTvnovreX97hkX9urJ+eXJBL98z01AXkUiJVt2DcD2QBC8OhZReb2Y2SBgMPmdn0JtZ/TFJ/QMAK4MakRuuca9SbG8sYOyiHWz55DCPyejI8t3WjjbqOKSUJxczGxJi/BTgimZjZy8DLEdNnJys251zzFe06wIUnDOLs4wamOhSXQu3hLi/nXAe2t7KK8gNVDO3nVyVdnScU51yrFO8+AMDQft1THIlLNU8ozrlWKSqrSyh+hdLVeUJxzrVK0a7gRk2/QnGeUJxzrVK06wDZ3dLI65mZ6lBcinlCcc61StGuAwzt14PwEQDXhXlCcc61StHuCob09eou5wnFOddKwRWKJxTnCcU51wr7Dlazu8KfQXEBTyjOuRYr3uXPoLiPeEJxzrWY3zLsInlCcc61WNEuf6jRfcQTinOuxYp2VZCVkUZ+L38GxXlCcc61Qt0dXv4MigNPKM65VijadYAhXt3lQp5QnHMtVrSrwhvkXT1PKM65Ftl/sJpdFVWeUFy9lCQUSXdJWitppaT5kvrGKLdR0ipJKyQtjZifK2mhpHXhz35tF71zDiLHQfEqLxdI1RXKQmC8mU0E3gPmNFL2LDObZGaFEfO+BbxoZkcDL4bTzrk25M+guIaaTCiSlkr6ciKvAsxsgZlVh5OLgaHN3MRMYF74fh5wcaJic87Fp8ifkncNxHOFcgUwGHhT0u8kfVKJvUfweuC5GMsMWCBpmaTZEfMHmtlWgPDngFgblzQ7TIpLS0pKEha0c11d0a4DZGWk0b9XVqpDce1EkwnFzN43s7nAMcDjwK+ADyV9T1JurPUkvSBpdZTXzIgyc4Fq4LEYmznVzE4CLgC+LOmMZhxbXfwPmlmhmRX279+/uas752Io2hV0W+/PoLg6GfEUkjQRmAVMB/5IkABOA14CJkVbx8zOaWKb1wIzgGlmZjG2sSX8uUPSfGAy8CqwXdIgM9sqaRCwI57jcM4lRm2tsXzTbk4Y1ifVobh2JJ42lGXAPcCbwEQz+6qZLTGzHwPrW7JTSecDtwIXmVlFjDI9JfWuew+cB6wOF/8ZuDZ8fy3wdEvicM61zNJNu9i2p5LpEwalOhTXjsRzhfIZMzsscUgqMLMNZnZpC/d7P5AFLAwvlxeb2Y2SBgMPmdl0YCAwP1yeATxuZs+H6/8QeELSDcCHwGdaGIdzrgWeWbmF7G5pnHP8wFSH4tqReBLKk8BJUead3NKdmtmYGPO3EFSrESaxE2KUKwWmtXT/zrmWq66p5dlVWzn7uAH0zIqr1tx1ETE/DZKOA8YBfSRFXonkANnJDsw51z4t2VDGzn2HuHDi4FSH4tqZxr5eHEvQaN4XuDBi/l7g35IZlHOu/Xpm5RZ6ZqZz1nEx79Z3XVTMhGJmTwNPS/qYmb3ehjE559qpqppanlu9jXPGDiS7W3qqw3HtTGNVXv9pZncCn5f0uYbLzeyrSY3MOdfu/OP9neyuqPLqLhdVY1Vea8KfSxsp45zrQv7yry30zs7g9GPyUx2Ka4caq/L6S/hzXqwyzrmu41B1LQvf2c55Y48iK8Oru9yR4nmwcWFk9/KS+kn6W3LDcs61N699sJO9ldVMn3BUqkNx7VQ8nUP2N7PddRNmtotGOmN0znVOz6/aRq+sDE472qu7XHTxJJQaScPrJiSNIOgF2DnXRVTX1LLgnW1MO36AV3e5mOJ5zHUu8A9Jr4TTZwCzGynvnOtklmwoY1dFFReM9+ouF1uTCcXMnpd0EjAVEPANM9uZ9Micc+3Gc6u30r1bOmce47XdLraYVV5h1yuEyWQ4sAUoBoaH85xzXUBNrfG3t7dz1nH96Z7p1V0utsauUG4mqNr6cZRlBpydlIicc+3Ksk27KNl7kPPHe1f1rnGNPYdS105ygZlVRi6T5J1DOtcFmBnPrNxCZkYaZ3vfXa4J8TTK/5Mju6+PNs8510ns2FPJH5YV8ae3ilm3Yx+fmjCIXt5VvWtCY315HQUMAbpLOpGgQR6C7ut7tEFszrkUqKk1Pv3AP9lcdoDCEf34/sXjueTEIakOy3UAjX3l+CRwHTCUoB2lLqHsBb7dmp1KuougS/xDwAfArMiHJyPKbQz3VwNUm1lhOP82gi70S8Ki3zazZ1sTk3Mu8ObGMjaXHeAnl5/ApScNTXU4rgNprA1lHjBP0qfN7I8J3u9CYI6ZVUv6ETCHYIz5aM6KcZvyPWZ2d4Ljcq7Le2blFrp3S+d8f+bENVM8T8oPlZSjwEOSlks6rzU7NbMFZlYdTi4muApyzqVYdU0tz63axtnHD6BHpreZuOaJJ6Fcb2Z7gPMI+vCaBfwwgTFcDzwXY5kBCyQtk9Tw6fybJK2U9CtJ/WJtXNJsSUslLS0pKYlVzDkHvL6+lNL9Pryva5l4Ekpd28l04GEz+1fEvNgrSS9IWh3lNTOizFygGngsxmZONbOTgAuAL0s6I5z/M2A0MAnYSvRnZQAwswfNrNDMCvv3799U2M51ac/8ayu9sjL4xLH+v+KaL55r2mWSFgAFwBxJvYHaplYys3MaWy7pWoIx66eZWdTOJs1sS/hzh6T5wGTgVTPbHrGdXwDPxHEczrlGHKqu5fm3t3GuD+/rWiieK5QbgG8Bp5hZBZBJUO3VYpLOJ2iEvyjcZrQyPcPkhaSeBFVuq8PpyEd2L6mb75xrudfe30n5gSpmTPQn4l3LxNM5ZK2kDcAxCXxC/n4gC1goCWCxmd0oaTDwkJlNBwYC88PlGcDjZvZ8uP6dkiYRtLFsBL6YoLic65LMjD+tKCYnO4PTj/bqLtcyTSYUSV8AvkZwJ9YKgl6HX6cVfXmZ2ZgY87cQtNVgZuuBE2KUu7ql+3bOfWTH3kqeWl7MU8uLeG/7Pj4/ZTiZGfFUXDh3pHjaUL4GnEJwFXFW2Avx95IblnMu2apqarnop6+xbU8lJ4/oxx2XjOfT/iCja4V4EkqlmVVKQlKWma2VdGzSI3POJdXq4nK27ank7s+cwGUneyJxrRdPQimS1Bf4E0Gbxy6CsVGccx3Y6+tLAfwWYZcw8TTKXxK+vU3SIqAP8HwjqzjnOoDF68s4ekAv8ntlpToU10k01ttwbpTZq8KfvYCypETknEu6qppalm4s86oul1CNXaEsI7gtN/Kp+LppA0YlMS7nXBKtLCqn4lANU0flpToU14k01ttwQVsG4pxrO4vD9pMpBdEqIpxrmZg3nEu6KuL9qQ2W3ZTMoJxzybV4fSnHDuxNnrefuARq7AmmmyPe/7TBsuuTEItzrg0cqq5l6cZdfGy0V3e5xGosoSjG+2jTzrkOYmXRbg5U1TB1lFd3ucRqLKFYjPfRpp1zHcRH7Sd+heISq7G7vI6TtJLgamR0+J5w2u/wcq6Den19Kccd1Zt+PTNTHYrrZBpLKMe3WRTOuTZRsvcgSzfu4vNThqc6FNcJNXbb8Ka2DMQ5l3z/+9waas24csqIVIfiOiHvp9q5LmLJ+lKeWl7M7DNGMWZAr1SH4zohTyjOdQFVNbV89+nVDOnbnZvOOjrV4bhOKq6EIql7Irusl3SXpLWSVkqaH/ZmHK1cX0lPhmXXSPpYOD9X0kJJ68Kf/RIVm3Od0cOvbeC97fv43kXj6J7p48W75GgyoUi6kGCkxufD6UmS/tzK/S4ExpvZROA9YE6McvcBz5vZcQSjN64J538LeNHMjgZeDKedc1EcOFTDvS+s45zjB3DO2IGpDsd1YvFcodwGTAZ2A5jZCmBka3ZqZgvMrDqcXEwwvPBhJOUAZwC/DNc5ZGa7w8UzgXnh+3nAxa2Jx7nO7O0tQUeQV5zid3a55IonoVSbWXkSY7geeC7K/FFACfCwpLckPSSpZ7hsoJltBQh/Doi1cUmzJS2VtLSkpCTRsTvX7q0qDv59Jwztk+JIXGcXT0JZLenzQLqkoyX9FPhnUytJekHS6iivmRFl5gLVwGNRNpEBnAT8zMxOBPbTgqotM3vQzArNrLB/fx+ZznU9q4rKGdA7i4E52akOxXVy8QwB/BVgLnAQeBz4G3B7UyuZ2TmNLZd0LTADmGZm0bpyKQKKzGxJOP0kHyWU7ZIGmdlWSYOAHXEch3Nd0qriciYM8asTl3xNXqGYWYWZzTWzU8LXd8yssjU7lXQ+cCtwkZlVxNjvNmBzxN1l04B3wvd/Bq4N318LPN2aeJzrrPYfrOb9kn1e3eXaRDx3eS2MvK1XUj9Jf2vlfu8HegMLJa2Q9EC47cGSno0o9xXgsbAfsUnAD8L5PwTOlbQOODecds418M7WPZjhVyiuTcRT5ZUfcXcVZrZLUsxG8HiY2ZgY87cA0yOmVwCFUcqVElyxOOcasbIobJD3hOLaQDyN8rWS6u83lDQC777euQ5hdXE5A3OyGOAN8q4NxHOFMhf4h6RXwukzgNnJC8k5lyjeIO/aUpMJxcyel3QSMJVgLJRvmNnOpEfmnGuVfQer+aBkHxdOHJzqUFwXEbPKS9Jx4c+TgOHAFqAYGB7Oc85oH2aMAAAZ80lEQVS1Y+9sCRvkh+akOhTXRTR2hXIzQdXWj6MsM+DspETknEuIlUXBvTTjvcrLtZHGBtiaHf48q+3Ccc4lyurico7KyWZAb2+Qd22jyTYUSddEm29mjyY+HOdcoqwsLvcHGl2biucur1Mi3mcTPP+xHPCE4lw7taeyig0793PxpCGpDsV1IfHc5fWVyGlJfYBfJy0i51yr/fP9UsxgckFuqkNxXUhLhgCuAHwMUefasVfe20HvrAxOHuGDmbq2E08byl/46Mn4NGAs8EQyg3LOtZyZsWhtCacdnU+39JZ8Z3SuZeJpQ7k74n01sMnMipIUj3OuldZu28u2PZWcdWyrutxzrtniaUN5pakyzrn24+V3g5FJzzzWB5RzbStmQpG0l9idQB4EPgDmmtmLyQjMOdcyi97dwdhBOT5Co2tzjT3Y2DvWMknpwHiCoXvHJyEu51wL7KmsYtmmXdx45qhUh+K6oBa12JlZjZn9C/hpguNxzrXCP9btpKbW+IS3n7gUaNUtIGb280QF4pxrvZff3UFOdgYnDuvbdGHnEiwl9xRKukvSWkkrJc2PHGK4Qbm+kp4My66R9LFw/m2SisPhg1dImh5tfee6EjNj0bslnH5MfzL8dmGXAnF96iSNkHRO+L67pJjtK3FaCIw3s4nAe8CcGOXuA543s+OAE4A1EcvuMbNJ4evZ6Ks713Ws2Lybkr0H/XZhlzJNJhRJ/wY8CdRVbw0F/tSanZrZAjOrDicXh9tsuN8cgtEhfxmucyhybHvn3OGeWl5MVkYanxw3MNWhuC4qniuULwOnAnsAzGwdkMivQNcDz0WZPwooAR6W9JakhyT1jFh+U1hl9itJMfuXkDRb0lJJS0tKShIYtnPtx8HqGv6ycgufHHcUvbO7pToc10XFk1AOmtmhuglJGcR+PoWIci9IWh3lNTOizFyCp+8fi7KJDOAk4GdmdiKwH/hWuOxnwGhgErCV6IOAAWBmD5pZoZkV9u/vD3q5zmnR2h3srqji0pO8d2GXOvF0vfKKpG8D3SWdC/w78JemVjKzcxpbLulaYAYwzcyiJagioMjMloTTTxImFDPbHrGdXwDPxHEcznVaf1xezIDeWZw2Jj/VobguLJ4rlG8RVD2tAr4IPAt8pzU7lXQ+cCtwkZlVRCtjZtuAzZKODWdNA94J1x8UUfQSYHVr4nGuIyvbf4hFa3dw8YlD/O4ul1Lx9OVVC/wifCXK/UAWsFASwGIzu1HSYOAhM6u7DfgrwGOSMoH1wKxw/p2SJhFUvW0kSHTOdUl/XlFMda15dZdLuXi6r1/FkW0m5cBS4HYzK23uTs1sTIz5W4DpEdMrgMIo5a5u7j6d66yeequYsYNyOO6onFSH4rq4eNpQngNqgMfD6SvCn3uAR4ALEx+Wcy4eG3fuZ2VROd/51PGpDsW5uBLKqWZ2asT0Kkmvmdmpkq5KVmDOuaYt/3AXAKcf7XcwutSLpwWvl6QpdROSJgO9wsnq6Ks459rCquJyundLZ3T/nk0Xdi7J4rlC+QLwK0m9ABFUdX0hfMjwf5MZnHOucauKyhk7OMfv7nLtQjx3eb0JTJDUB1CD7k98bHnnUqSm1nh7yx4+e8qwVIfiHBDfXV5ZwKeBkUBGeJsvZvY/SY3MOdeoD0r2caCqhglD+qQ6FOeA+Kq8nia4TXgZwdC/zrl2YFVROQAThnpCce1DPAllqJmdn/RInHPN8lGDfK+mCzvXBuJpyfunpAlJj8Q51yyrissZNziH9DSlOhTngPgSymnAMknvht3Fr5K0MtmBOediq66p5e0t5V7d5dqVeKq8Lkh6FM65ZvmgZD+VVbXeIO/alXhuG94EIGkAkJ30iJxzTVpZFNy9P9GvUFw7Es8QwBdJWgdsAF4h6N032giLzrk2srq4nB6Z6RTke4O8az/iaUP5PjAVeM/MCgjGJXktqVE55xq1sric8YP7eIO8a1fiSShVYRf1aZLSzGwRwdC7zrkUqK6p5Z0texjv7SeunYmnUX532I/XqwSDXe3AO4V0LmXWbtvLwepaJgz18U9c+xLPFcpMoAL4BvA88AGtHANF0l2S1oa3Ic+X1DdKmWMlrYh47ZH09XBZrqSFktaFP/u1Jh7nOpI//2sLGWnitDHeZb1rXxpNKJLSgafNrNbMqs1snpn9X0tGaWxgITDezCYC7wFzGhYws3fNbJKZTQJOJkhq88PF3wJeNLOjgRfDaec6vaqaWp5aXsTZxw2gf++sVIfj3GEaTShmVgNUhD0NJ4yZLTCzumqzxcDQJlaZBnxQdwszwVXTvPD9PODiRMbnXHu1aO0Odu47xOWF3sOwa3/iaUOpJBilcSGwv26mmX01QTFcD/y+iTJXAL+NmB5oZlvDOLaGz8hEJWk2MBtg+PDhrQzVudR6YmkR/Xtn8YljvbrLtT/xJJS/hq9mkfQCcFSURXPN7OmwzFyCBv7HGtlOJnARUarF4mFmDwIPAhQWFlpLtuFce7BjbyWL3t3BF04v8AG1XLsUT0L5PTAGMIJqp8p4Nmxm5zS2XNK1wAxgmpk1dqK/AFhuZtsj5m2XNCi8OhkE7IgnJuc6svnLi6mpNa/ucu1WzK85kjIk3QkUEbRT/AbYLOlOSd1as1NJ5wO3AheZWUUTxT/H4dVdAH8Grg3fX0swZotznZaZ8cTSzRSO6Ofd1bt2q7Hr5ruAXKDAzE42sxOB0UBf4O5W7vd+oDewMLwl+AEASYMlPVtXSFIP4FzgqQbr/xA4N+wS5txw2rlOaVVROV///Qo+KNnvVyeuXWusymsGcExkdZSZ7ZH0JWAt8LWW7tTMxsSYvwWYHjFdAeRFKVdKcOeXc52OmfHe9n38fV0Jz63exrJNu+iZmc71pxZw8YlDUh2eczE1llAsWtuGmdVI8sZt55JgVVE5s3+9lK3lQVPl0QN68d0ZY/lM4VBysltV0+xc0jWWUN6RdI2ZPRo5U9JVBFcozrkE+8Gza6iqqeXOT0/ktKPzGdy3e6pDci5ujSWULwNPSboeWEZwl9cpQHfgkjaIzbku5Y0NZby+vpTvzhjL5ad4W4nreGImFDMrBqZIOhsYBwh4zsxebKvgnOtK7nvxPfJ7ZfH5yf4AruuY4hmx8SXgpTaIxbkua+nGMl57v5S504+ne2Z6qsNxrkX8cVvn2oH7XlxHXs9MrpzqVyeu44rnSXnnXJJsLqvgqeXF/H3dTuZccBw9Mv1f0nVc/ul1rg3tO1jNig938+bGMl5dV8JbH+4G4NQxeVw1dUSKo3OudTyhOJdENbXGyqLdvPJeCa++V8KKzbupNUgTjBvch1vPP44ZEwcxLLdHqkN1rtU8oTiXQIeqa3lv+96gkf2DUhavL2VvZTUSTBzal3//xBgmF+Ry4vC+9PYHFV0n4wnFuVYo23+INzaUsnh9GW99uIs1W/dyqKYWgOG5PfjUhEF8fEw+p43JJ7dnZoqjdS65PKE41ww79x1kyfoylmwoZcn6Mt7dvheA7G5pTBrWl1mnjmTC0D5MGtaXof28Gst1LZ5QnGvEjj2VLN5QxpL1pSzZUMb7O/YB0CMznZNH9OOiSYOZUpDLxKF9yczwu/Bd1+YJxbkI28orWbIhaPtYsr6M9TuDUa97ZWVQOLIfnz5pKFNG5TJhSB+6+aiJzh3GE4rr0op3HwiuPtaXsXhDKZtKg/HeemdlcEpBLldMHsaUgjzGDc7xYXeda4InFNdlmBlFuw4EVx8bgnaQzWUHAOjTvRunjMzl6qkjmDoqj+MH5ZCephRH7FzHkpKEIuku4ELgEPABMMvMdjcocyzBePZ1RgH/ZWb3SroN+DegJFz2bTN7FucimBkfllXUV18tXl/KlnCckX49ujG5IJdZHy9gyqhcjj8qhzRPIM61SqquUBYCc8ysWtKPgDkEY8zXM7N3gUkAktKBYmB+RJF7zKy1QxG7TsTM2LBzP0s2lNUnkW17ggSS1zOTKaNy+WJBHlNG5XLMgN6eQJxLsJQkFDNbEDG5GLisiVWmAR+Y2abkReU6GjPjg5J9vL7+o7uwSvYeBKB/7yymFOQyZVQeHxuVy+j+vZA8gTiXTO2hDeV6Dq/aiuYK4LcN5t0k6RpgKfBNM9uVjOBc+1Fba6zbsa/+GZAlG0rZue8QAEflZPPx0XlMHZXHlIJcCvJ7egJxro0pyrDxidmw9AJwVJRFc83s6bDMXKAQuDTa+PVhmUxgCzDOzLaH8wYCOwlGkfw+MMjMro+x/mxgNsDw4cNP3rTJL3I6itpaY+22vfUJ5I2NZZTtDxLIoD7ZTB2Vx9RRuUwpyGNEXg9PIM4liaRlZlbYVLmkXaGY2TmNLZd0LTADmBYrmYQuAJbXJZNw2/XvJf0CeKaROB4EHgQoLCxMTvZ0CVFTa6zZuqf+Lqw3NpRRfqAKgKH9unPWsQOYOiqXqaPyGNqvuycQ59qZVN3ldT5BI/yZZlbRRPHP0aC6S9IgM9saTl4CrE58lC7ZqmtqeXvLnsOuQPZWVgMwIq8Hnxw3kCkFeUwdnceQvt1THK1zrimpakO5H8gCFobfMheb2Y2SBgMPmdl0AEk9gHOBLzZY/05JkwiqvDZGWe7aoaqaWlYXl9ffhbV04y72HQwSyKj8nsyYOIgp4V1Yg/p4AnGuo0nVXV5jYszfAkyPmK4A8qKUuzp50blEOVRdy6ri3SwOnwFZtmkXFYdqABjdvycXTRoctIMU5DIgJzvF0TrnWqs93OXlOomD1TX8a3M5S9aXsnhDkEAqq4Ku3I8Z2Ku+H6wpBXn0752V4midc4nmCcW1WGVVDW99uLu+M8W3PtzNweoggRx3VG+uOGU4U0flcsrIXPJ6eQJxrrPzhOLiduBQDW99uIvF60tZvKGMFR/u5lBNLRKMHZTDlVNGMGVULpNH5tLPB5NyrsvxhOJiqjhUzbJNu+ofIlyxeTdVNUaaYPyQPlz78RFMKcjjlIJc+nT34Wyd6+o8obh6+w5Ws3RjWf1dWKuKyqmuNdLTxIQhfbj+tAKmFuRx8sh+5Ph46M65BjyhdGF7KquCBLK+jMUbylhdXE5NrZGRJk4Y1pfZZ4xiyqg8Th7Rj15Z/lFxzjXOzxJdSHlFFW9sLKu/C+udLXuoNchMT+OEYX340pmjmToqj5NG9KVHpn80nHPN42eNTmzX/kP1A0ktWV/Gmm17MIPMjDROHNaXr5x9NFNG5XLS8H5kd0tPdbjOuQ7OE0onUrrvYJBAwr6w1m7bC0BWRhonj+jH16cdw9RRuZwwrK8nEOdcwnlC6cB27K3kjQ1l9aMRrtuxD4Du3dIpHNkv6MpkVB4Th/YhK8MTiHMuuTyhdCDb91TW98S7eH0p60v2A9AzM52TR+ZyyUlDmFKQx4QhfcjMSEtxtM65rsYTSju2ZfeBiMGkytiwM0ggvbMyOKUgl88WDmPKqDzGD84hI90TiHMutTyhtCObyyrq20AWbyhlc9kBAHKyM5hckMuVU4YzpSCPsYNzSPfx0J1z7YwnlBQxMzaXHWBx2A/WkvVlFO8OEkjfHt2YPDKX6z5ewJSCXI4f5AnEOdf+eUJpI2bGxtKKMHkE7SBbyysByO2ZyZSCXP7t9AKmjs7jmAG9SfME4pzrYDyhJImZsX7n/vqrj8XrS9mx9yAA+b2ymDIql6kFwXC2Ywb08uFsnXMdnieUBDEz1u3YF7Z/BOOhl4QJZEDvLKaMymNqOBbI6P49PYE45zqdlCUUSXcBFwKHgA+AWWa2O0q5bwBfIBjud1VYrlJSAfA7IBdYDlxtZofaKv7aWuPd7Xvrq6+WbCijbH+w+0F9sjl1dB5TR+UxZVQeI/N6eAJxznV6qbxCWQjMMbNqST8C5gC3RhaQNAT4KjDWzA5IegK4AngE+BFwj5n9TtIDwA3Az5IVbE2tsWbrnvq7sN7YWMbuiioAhvTtzieO7c/UgiCJDMvt7gnEOdflpCyhmNmCiMnFwGUximYA3SVVAT2ALQrO1mcDnw/LzANuI0kJ5f9eXMdDf1/PnspqAIbn9uDc4wcydVQekwtyGZbbIxm7dc65DqW9tKFcD/y+4UwzK5Z0N/AhcABYYGYLJOUDu82sOixaBAyJtmFJs4HZAMOHD29RcEflZDN9wqD68dAH9+3eou0451xnltSEIukF4Kgoi+aa2dNhmblANfBYlPX7ATOBAmA38AdJVwF/i7JNixaDmT0IPAhQWFgYtUxTLj9lGJefMqwlqzrnXJeR1IRiZuc0tlzStcAMYJqZRTvZnwNsMLOSsPxTwMcJkk9fSRnhVcpQYEtCg3fOOdcsKesAStL5BI3wF5lZRYxiHwJTJfUI202mAWvC5LOIj9pdrgWeTnbMzjnnYktlj4L3A72BhZJWhHdqIWmwpGcBzGwJ8CTBbcGrCOJ9MFz/VuBmSe8DecAv2zh+55xzERS9pqlzKiwstKVLl6Y6DOec61AkLTOzwqbKeZ/nzjnnEsITinPOuYTwhOKccy4hPKE455xLiC7VKC+pBNjUwtXzgZ0JDKe96czH58fWcXXm4+tIxzbCzPo3VahLJZTWkLQ0nrscOqrOfHx+bB1XZz6+znhsXuXlnHMuITyhOOecSwhPKPF7sOkiHVpnPj4/to6rMx9fpzs2b0NxzjmXEH6F4pxzLiE8oTjnnEuILp9QJP1K0g5JqyPm5UpaKGld+LNfjHWvDcusC8d2aXdaenySJkl6XdLbklZK+mzbRt601vztwrI5kool3d82EcevlZ/L4ZIWSFoj6R1JI9sq7ni18vjuDD+XayT9Xzi0RbsR49g+E8ZcKynmrcKSzpf0rqT3JX2rbSJOnC6fUIBHgPMbzPsW8KKZHQ28GE4fRlIu8N/AFGAy8N+NnbxS6BFacHxABXCNmY0L179XUt9kBtoCj9CyY6vzfeCV5ITWao/Q8mN7FLjLzI4n+GzuSFaQrfAILfu/+zhwKjARGA+cApyZ1Eib7xGOPLbVwKXAq7FWkpQO/D/gAmAs8DlJY5MUY1J0+YRiZq8CZQ1mzwTmhe/nARdHWfWTwEIzKzOzXcBCjvwQpVxLj8/M3jOzdeH7LQQnpSaflG1LrfjbIelkYCCwIGkBtkJLjy08AWWY2cJwO/saGcAuZVrxtzMgG8gEsoBuwPYkhdki0Y7NzNaY2btNrDoZeN/M1pvZIeB3BL+TDqPLJ5QYBprZVoDw54AoZYYAmyOmi8J5HUE8x1dP0mSCf+AP2iC21mry2CSlAT8G/qONY2uteP5uxwC7JT0l6S1Jd4XffDuCJo/PzF4nGK11a/j6m5mtadMok6cjn1MATyitEa3ettPdgy1pEPBrYJaZ1aY6ngT5d+BZM9vcZMmOJwM4HbiFoDpoFHBdKgNKJEljgOOBoQQn27MlnZHaqBKmw59TPKFEtz08kdadUKPVQRcBwyKmhwJb2iC2RIjn+JCUA/wV+I6ZLW7D+FojnmP7GHCTpI3A3cA1kn7YdiG2WLyfy7fCapNq4E/ASW0YY2vEc3yXAIvDqrx9wHPA1DaMMZk68jkF8IQSy5+Buru2rgWejlLmb8B5kvqFjfHnhfM6giaPT1ImMB941Mz+0IaxtVaTx2ZmV5rZcDMbSfBN/lEz6wh31MTzuXwT6Ceprr3rbOCdNogtEeI5vg+BMyVlSOpG0CDfWaq83gSOllQQ/v9dQfA76TjMrEu/gN8S1MVWEXxDuAHII7jLZF34MzcsWwg8FLHu9cD74WtWqo8lkccHXBWusyLiNSnVx5Oov13ENq4D7k/1sST4c3kusBJYRXDHUWaqjyeBn8t04OcESeQd4CepPpY4j+2S8P1BgpsI/haWHUxQ/Vq37nTgPYL2yrmpPpbmvrzrFeeccwnhVV7OOecSwhOKc865hPCE4pxzLiE8oTjnnEsITyjOOecSwhOKc865hPCE4pxzLiE8oTgXhaR9rVi3u6RX6jplbM22Ek1SpqRXJWWkOhbX+XhCcS7xrgeeMrOaVAfSkAXdor8ItLsB01zH5wnFuUZIulnS6vD19Yj535W0NhxZ8LeSbolY7Uqi9482Mhxl8Bfh6H0LJHUPl10Tjoz5L0m/bmLfI8N9PxQue0zSOZJeC0c7nByWu0rSG5JWSPp5RDf2fwpjdC6xUt33i7/81R5fwD7gZIL+sHoCvYC3gRMJ+pZaAXQHehP0PXVLuF4msK3htsKfI4Fqwj7RgCcI+kwbB7wL5Ifzc2Ptu8F2JhB8KVwG/Iqg+/OZBAnjeOAvQLdwnf+PYAROCPrDKkn179hfne/l9ajOxXYaMN/M9gNIeopgrJE04GkzOxDO/0vEOvnA7ka2ucHMVoTvlxEkh37Ak2a2E8DMyiRdHWPfb0VsZ1W47G2CoXNN0qpwm9MIktKb4ZDr3Qm7gzezGkmHJPU2s70t+s04F4UnFOdiizbgUWPzAQ4QDFEby8GI9zUEJ3px5EBKje2j4XZqI6ZrCf6vBcwzszkx1s8CKpvYh3PN4m0ozsX2KnCxpB6SehJ0Qf534B/AhZKyJfUCPlW3gpntAtIlNZZUGnoRuFxSHoCk3Eb23ZxtXiZpQN02JY0I3+cRVHlVNWN7zjXJr1Cci8HMlkt6BHgjnPWQmb0FIOnPwL+ATcBSoDxi1QUE1WUvxLmftyXdAbwiqYZgxMXrYu07zm2+I+k7wAJJaQRjc3w5jPcs4Nl4t+VcvHw8FOdaQFIvM9snqQfB1cRsM1seLjsRuNnMrk5pkDGE7TFzzOzdVMfiOhe/QnGuZR6UNJagvWReXTIBMLO3JC2SlG7t7FmUcGjZP3kyccngVyjOOecSwhvlnXPOJYQnFOeccwnhCcU551xCeEJxzjmXEJ5QnHPOJYQnFOeccwnhCcU551xC/P8BLOQO/GMpPwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1022,161 +1084,14 @@ ], "source": [ "# Plot Orange Juice elasticity as a function of income\n", - "plt.plot(np.ndarray.flatten(X_test), te_pred[:, 0], label=\"OJ Elasticity\")\n", + "plt.plot(X_test.flatten(), treatment_effects, label=\"OJ Elasticity\")\n", + "plt.fill_between(X_test.flatten(), te_lower, te_upper, label=\"90% BLB CI\", alpha=0.3)\n", "plt.xlabel(r'$\\log$(Income)')\n", "plt.ylabel('Orange Juice Elasticity')\n", "plt.legend()\n", "plt.title(\"Orange Juice Elasticity vs Income\")\n", "plt.show()" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 4.4 Bootstrap Confidence Intervals\n", - "\n", - "We can also use a bootstrap estimator to generate confidence intervals by changing how we call `fit`; in order to return results in a few minutes we're limiting the number of trees to 100 and the number of bootstrap samples to 10 in the code below, but for better estimates these numbers can be increased at the cost of increased runtime." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from econml.inference import BootstrapInference\n", - "est = ContinuousTreatmentOrthoForest(\n", - " n_trees=100, min_leaf_size=min_leaf_size, max_depth=max_depth, \n", - " subsample_ratio=subsample_ratio, bootstrap=bootstrap, \n", - " model_T=Lasso(alpha=0.1),\n", - " model_Y=Lasso(alpha=0.1),\n", - " model_T_final=WeightedLassoCVWrapper(cv=3), \n", - " model_Y_final=WeightedLassoCVWrapper(cv=3)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 0.2s finished\n", - "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 0.1s finished\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.3s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.7s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.7s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.2s finished\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.3s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.3s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.3s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.4s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.3s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.4s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.3s finished\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.7s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.7s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.7s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.5s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.5s\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 2.4s finished\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.6s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.6s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.6s finished\n", - "[Parallel(n_jobs=-1)]: Done 3 out of 10 | elapsed: 7.8s remaining: 18.4s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.6s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.5s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.5s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.5s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 3.5s finished\n", - "[Parallel(n_jobs=-1)]: Done 7 out of 10 | elapsed: 8.0s remaining: 3.4s\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 1.9s finished\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.1s\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.1s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 0.5s finished\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Done 16 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 0.8s finished\n", - "[Parallel(n_jobs=-1)]: Done 100 out of 100 | elapsed: 0.6s finished\n", - "[Parallel(n_jobs=-1)]: Done 10 out of 10 | elapsed: 9.6s finished\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n", - "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n" - ] - } - ], - "source": [ - "est.fit(Y, T, X, W, inference=BootstrapInference(n_bootstrap_samples=10, n_jobs=-1))\n", - "te_pred_interval = est.const_marginal_effect_interval(X_test, alpha=0.02)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.plot(np.ndarray.flatten(X_test), te_pred[:, 0], label=\"OJ Elasticity\")\n", - "plt.fill_between(np.ndarray.flatten(X_test), \n", - " te_pred_interval[0][:, 0], \n", - " te_pred_interval[1][:, 0], alpha=.5, label=\"1-99% CI\")\n", - "plt.xlabel(r'$\\log$(Income)')\n", - "plt.ylabel('Orange Juice Elasticity')\n", - "plt.title(\"Orange Juice Elasticity vs Income\")\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] } ], "metadata": {