Implement more feedback

Author: kbattocchi

econml/bootstrap.py

@@ -48,15 +48,15 @@ class BootstrapEstimator:
         that should be preferred (meaning this wrapper will compute the mean of it).
         This option only affects behavior if `compute_means` is set to ``True``.
 
-    bootstrap_type: 'percentile', 'pivot', or 'normal', default 'percentile'
+    bootstrap_type: 'percentile', 'pivot', or 'normal', default 'pivot'
         Bootstrap method used to compute results.  'percentile' will result in using the empiracal CDF of
         the replicated computations of the statistics.   'pivot' will also use the replicates but create a pivot
         interval that also relies on the estimate over the entire dataset.  'normal' will instead compute an interval
         assuming the replicates are normally distributed.
     """
 
     def __init__(self, wrapped, n_bootstrap_samples=1000, n_jobs=None, compute_means=True, prefer_wrapped=False,
-                 bootstrap_type='percentile'):
+                 bootstrap_type='pivot'):
         self._instances = [clone(wrapped, safe=False) for _ in range(n_bootstrap_samples)]
         self._n_bootstrap_samples = n_bootstrap_samples
         self._n_jobs = n_jobs
@@ -162,8 +162,7 @@ def percentile_bootstrap(arr, _):
                 def pivot_bootstrap(arr, est):
                     return 2 * est - np.percentile(arr, upper, axis=0), 2 * est - np.percentile(arr, lower, axis=0)
 
-                def normal_bootstrap(arr, _):
-                    est = np.mean(arr, axis=0)
+                def normal_bootstrap(arr, est):
                     std = np.std(arr, axis=0)
                     return est - norm.ppf(upper / 100) * std, est - norm.ppf(lower / 100) * std
 

econml/inference.py

@@ -32,7 +32,37 @@ def fit(self, estimator, *args, **kwargs):
         pass
 
 
-class BootstrapInference(Inference):
+class _SummaryMixin:
+    def summary(self, alpha=0.1, value=0, decimals=3, feat_name=None):
+        smry = Summary()
+        try:
+            coef_table = self.coef__inference().summary_frame(alpha=alpha,
+                                                              value=value, decimals=decimals, feat_name=feat_name)
+            coef_array = coef_table.values
+            coef_headers = [i + '\n' +
+                            j for (i, j) in coef_table.columns] if self.d_t > 1 else coef_table.columns.tolist()
+            coef_stubs = [i + ' | ' + j for (i, j) in coef_table.index] if self.d_y > 1 else coef_table.index.tolist()
+            coef_title = 'Coefficient Results'
+            smry.add_table(coef_array, coef_headers, coef_stubs, coef_title)
+        except Exception as e:
+            print("Coefficient Results: ", str(e))
+        try:
+            intercept_table = self.intercept__inference().summary_frame(alpha=alpha,
+                                                                        value=value, decimals=decimals, feat_name=None)
+            intercept_array = intercept_table.values
+            intercept_headers = [i + '\n' + j for (i, j)
+                                 in intercept_table.columns] if self.d_t > 1 else intercept_table.columns.tolist()
+            intercept_stubs = [i + ' | ' + j for (i, j)
+                               in intercept_table.index] if self.d_y > 1 else intercept_table.index.tolist()
+            intercept_title = 'Intercept Results'
+            smry.add_table(intercept_array, intercept_headers, intercept_stubs, intercept_title)
+        except Exception as e:
+            print("Intercept Results: ", str(e))
+        if len(smry.tables) > 0:
+            return smry
+
+
+class BootstrapInference(_SummaryMixin, Inference):
     """
     Inference instance to perform bootstrapping.
 
@@ -46,21 +76,20 @@ class BootstrapInference(Inference):
     n_jobs: int, optional (default -1)
         The maximum number of concurrently running jobs, as in joblib.Parallel.
 
-    bootstrap_type: 'percentile', 'pivot', or 'normal', default 'percentile'
+    bootstrap_type: 'percentile', 'pivot', or 'normal', default 'pivot'
         Bootstrap method used to compute results.
         'percentile' will result in using the empiracal CDF of the replicated computations of the statistics.
         'pivot' will also use the replicates but create a pivot interval that also relies on the estimate
         over the entire dataset.
         'normal' will instead compute a pivot interval assuming the replicates are normally distributed.
     """
 
-    def __init__(self, n_bootstrap_samples=100, n_jobs=-1, bootstrap_type='percentile'):
+    def __init__(self, n_bootstrap_samples=100, n_jobs=-1, bootstrap_type='pivot'):
         self._n_bootstrap_samples = n_bootstrap_samples
         self._n_jobs = n_jobs
         self._bootstrap_type = bootstrap_type
 
     def fit(self, estimator, *args, **kwargs):
-        discrete_treatment = estimator._discrete_treatment if hasattr(estimator, '_discrete_treatment') else False
         est = BootstrapEstimator(estimator, self._n_bootstrap_samples, self._n_jobs, compute_means=False,
                                  bootstrap_type=self._bootstrap_type)
         est.fit(*args, **kwargs)
@@ -82,34 +111,6 @@ def wrapped(*args, alpha=0.1, **kwargs):
         else:
             return m
 
-    def summary(self, alpha=0.1, value=0, decimals=3, feat_name=None):
-        smry = Summary()
-        try:
-            coef_table = self.coef__inference().summary_frame(alpha=alpha,
-                                                              value=value, decimals=decimals, feat_name=feat_name)
-            coef_array = coef_table.values
-            coef_headers = [i + '\n' +
-                            j for (i, j) in coef_table.columns] if self.d_t > 1 else coef_table.columns.tolist()
-            coef_stubs = [i + ' | ' + j for (i, j) in coef_table.index] if self.d_y > 1 else coef_table.index.tolist()
-            coef_title = 'Coefficient Results'
-            smry.add_table(coef_array, coef_headers, coef_stubs, coef_title)
-        except Exception as e:
-            print("Coefficient Results: ", str(e))
-        try:
-            intercept_table = self.intercept__inference().summary_frame(alpha=alpha,
-                                                                        value=value, decimals=decimals, feat_name=None)
-            intercept_array = intercept_table.values
-            intercept_headers = [i + '\n' + j for (i, j)
-                                 in intercept_table.columns] if self.d_t > 1 else intercept_table.columns.tolist()
-            intercept_stubs = [i + ' | ' + j for (i, j)
-                               in intercept_table.index] if self.d_y > 1 else intercept_table.index.tolist()
-            intercept_title = 'Intercept Results'
-            smry.add_table(intercept_array, intercept_headers, intercept_stubs, intercept_title)
-        except Exception as e:
-            print("Intercept Results: ", str(e))
-        if len(smry.tables) > 0:
-            return smry
-
 
 class GenericModelFinalInference(Inference):
     """
@@ -215,7 +216,7 @@ def effect_inference(self, X, *, T0, T1):
                                       pred_stderr=e_stderr, inf_type='effect', fname_transformer=None)
 
 
-class LinearModelFinalInference(GenericModelFinalInference):
+class LinearModelFinalInference(_SummaryMixin, GenericModelFinalInference):
     """
     Inference based on predict_interval of the model_final model. Assumes that estimator
     class has a model_final method and that model is linear. Thus, the predict(cross_product(X, T1 - T0)) gives
@@ -318,34 +319,6 @@ def intercept__inference(self):
         return NormalInferenceResults(d_t=self.d_t, d_y=self.d_y, pred=intercept, pred_stderr=intercept_stderr,
                                       inf_type='intercept', fname_transformer=None)
 
-    def summary(self, alpha=0.1, value=0, decimals=3, feat_name=None):
-        smry = Summary()
-        try:
-            coef_table = self.coef__inference().summary_frame(alpha=alpha,
-                                                              value=value, decimals=decimals, feat_name=feat_name)
-            coef_array = coef_table.values
-            coef_headers = [i + '\n' +
-                            j for (i, j) in coef_table.columns] if self.d_t > 1 else coef_table.columns.tolist()
-            coef_stubs = [i + ' | ' + j for (i, j) in coef_table.index] if self.d_y > 1 else coef_table.index.tolist()
-            coef_title = 'Coefficient Results'
-            smry.add_table(coef_array, coef_headers, coef_stubs, coef_title)
-        except Exception as e:
-            print("Coefficient Results: ", str(e))
-        try:
-            intercept_table = self.intercept__inference().summary_frame(alpha=alpha,
-                                                                        value=value, decimals=decimals, feat_name=None)
-            intercept_array = intercept_table.values
-            intercept_headers = [i + '\n' + j for (i, j)
-                                 in intercept_table.columns] if self.d_t > 1 else intercept_table.columns.tolist()
-            intercept_stubs = [i + ' | ' + j for (i, j)
-                               in intercept_table.index] if self.d_y > 1 else intercept_table.index.tolist()
-            intercept_title = 'Intercept Results'
-            smry.add_table(intercept_array, intercept_headers, intercept_stubs, intercept_title)
-        except Exception as e:
-            print("Intercept Results: ", str(e))
-        if len(smry.tables) > 0:
-            return smry
-
 
 class StatsModelsInference(LinearModelFinalInference):
     """Stores statsmodels covariance options.