Merge branch 'main' into improve-causal-forest

Author: gdaiha

.github/workflows/ci.yml

@@ -201,12 +201,12 @@ jobs:
     if: ${{ needs.eval.outputs.testCode == 'True' }}
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-12]
         python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
         kind: [serial, other, dml, main, treatment, ray]
         exclude:
           # Serial tests fail randomly on mac sometimes, so we don't run them there
-          - os: macos-latest
+          - os: macos-12
             kind: serial
           # Ray tests run out of memory on Windows
           - os: windows-latest

econml/inference/_inference.py

@@ -1066,14 +1066,9 @@ def conf_int(self, alpha=0.05):
         """
         if self.stderr is None:
             raise AttributeError("Only point estimates are available!")
-        if np.isscalar(self.point_estimate):
+        else:
             return _safe_norm_ppf(alpha / 2, loc=self.point_estimate, scale=self.stderr), \
                 _safe_norm_ppf(1 - alpha / 2, loc=self.point_estimate, scale=self.stderr)
-        else:
-            return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err)
-                             for p, err in zip(self.point_estimate, self.stderr)]), \
-                np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err)
-                          for p, err in zip(self.point_estimate, self.stderr)])
 
     def pvalue(self, value=0):
         """
@@ -1398,14 +1393,8 @@ def conf_int_mean(self, *, alpha=None):
         alpha = self.alpha if alpha is None else alpha
         mean_point = self.mean_point
         stderr_mean = self.stderr_mean
-        if np.isscalar(mean_point):
-            return (_safe_norm_ppf(alpha / 2, loc=mean_point, scale=stderr_mean),
-                    _safe_norm_ppf(1 - alpha / 2, loc=mean_point, scale=stderr_mean))
-        else:
-            return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err)
-                             for p, err in zip(mean_point, stderr_mean)]), \
-                np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err)
-                          for p, err in zip(mean_point, stderr_mean)])
+        return (_safe_norm_ppf(alpha / 2, loc=mean_point, scale=stderr_mean),
+                _safe_norm_ppf(1 - alpha / 2, loc=mean_point, scale=stderr_mean))
 
     @property
     def std_point(self):

econml/sklearn_extensions/linear_model.py

@@ -1627,10 +1627,8 @@ def coef__interval(self, alpha=0.05):
         coef__interval : {tuple ((p, d) array, (p,d) array), tuple ((d,) array, (d,) array)}
             The lower and upper bounds of the confidence interval of the coefficients
         """
-        return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err)
-                         for p, err in zip(self.coef_, self.coef_stderr_)]), \
-            np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err)
-                      for p, err in zip(self.coef_, self.coef_stderr_)])
+        return (_safe_norm_ppf(alpha / 2, loc=self.coef_, scale=self.coef_stderr_),
+                _safe_norm_ppf(1 - alpha / 2, loc=self.coef_, scale=self.coef_stderr_))
 
     def intercept__interval(self, alpha=0.05):
         """
@@ -1651,14 +1649,8 @@ def intercept__interval(self, alpha=0.05):
             return (0 if self._n_out == 0 else np.zeros(self._n_out)), \
                 (0 if self._n_out == 0 else np.zeros(self._n_out))
 
-        if self._n_out == 0:
-            return _safe_norm_ppf(alpha / 2, loc=self.intercept_, scale=self.intercept_stderr_), \
-                _safe_norm_ppf(1 - alpha / 2, loc=self.intercept_, scale=self.intercept_stderr_)
-        else:
-            return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err)
-                             for p, err in zip(self.intercept_, self.intercept_stderr_)]), \
-                np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err)
-                          for p, err in zip(self.intercept_, self.intercept_stderr_)])
+        return (_safe_norm_ppf(alpha / 2, loc=self.intercept_, scale=self.intercept_stderr_),
+                _safe_norm_ppf(1 - alpha / 2, loc=self.intercept_, scale=self.intercept_stderr_))
 
     def predict_interval(self, X, alpha=0.05):
         """
@@ -1677,10 +1669,12 @@ def predict_interval(self, X, alpha=0.05):
         prediction_intervals : {tuple ((n,) array, (n,) array), tuple ((n,p) array, (n,p) array)}
             The lower and upper bounds of the confidence intervals of the predicted mean outcomes
         """
-        return np.array([_safe_norm_ppf(alpha / 2, loc=p, scale=err)
-                         for p, err in zip(self.predict(X), self.prediction_stderr(X))]), \
-            np.array([_safe_norm_ppf(1 - alpha / 2, loc=p, scale=err)
-                      for p, err in zip(self.predict(X), self.prediction_stderr(X))])
+
+        pred = self.predict(X)
+        pred_stderr = self.prediction_stderr(X)
+
+        return (_safe_norm_ppf(alpha / 2, loc=pred, scale=pred_stderr),
+                _safe_norm_ppf(1 - alpha / 2, loc=pred, scale=pred_stderr))
 
 
 class StatsModelsLinearRegression(_StatsModelsWrapper):

econml/tests/test_rscorer.py

@@ -21,9 +21,9 @@ def _fit_model(name, model, Y, T, X):
 class TestRScorer(unittest.TestCase):
 
     def _get_data(self):
-        X = np.random.normal(0, 1, size=(2000, 2))
-        T = np.random.binomial(1, .5, size=(2000,))
-        y = X[:, 0] * T + np.random.normal(size=(2000,))
+        X = np.random.normal(0, 1, size=(100000, 2))
+        T = np.random.binomial(1, .5, size=(100000,))
+        y = X[:, 0] * T + np.random.normal(size=(100000,))
         return y, T, X, X[:, 0]
 
     def test_comparison(self):