Merge pull request #227 from DoubleML/s-remove-apply-crossfitting

Remove `apply_crossfitting` and `dml_procedure` options from DoubleML class

Author: SvenKlaassen

doubleml/did/did.py

@@ -49,10 +49,6 @@ class DoubleMLDID(LinearScoreMixin, DoubleML):
         Indicates whether to use a sligthly different normalization from Sant'Anna and Zhao (2020).
         Default is ``True``.
 
-    dml_procedure : str
-        A str (``'dml1'`` or ``'dml2'``) specifying the double machine learning algorithm.
-        Default is ``'dml2'``.
-
     trimming_rule : str
         A str (``'truncate'`` is the only choice) specifying the trimming approach.
         Default is ``'truncate'``.
@@ -65,10 +61,6 @@ class DoubleMLDID(LinearScoreMixin, DoubleML):
         Indicates whether the sample splitting should be drawn during initialization of the object.
         Default is ``True``.
 
-    apply_cross_fitting : bool
-        Indicates whether cross-fitting should be applied.
-        Default is ``True``.
-
     Examples
     --------
     >>> import numpy as np
@@ -93,18 +85,14 @@ def __init__(self,
                  n_rep=1,
                  score='observational',
                  in_sample_normalization=True,
-                 dml_procedure='dml2',
                  trimming_rule='truncate',
                  trimming_threshold=1e-2,
-                 draw_sample_splitting=True,
-                 apply_cross_fitting=True):
+                 draw_sample_splitting=True):
         super().__init__(obj_dml_data,
                          n_folds,
                          n_rep,
                          score,
-                         dml_procedure,
-                         draw_sample_splitting,
-                         apply_cross_fitting)
+                         draw_sample_splitting)
 
         self._check_data(self._dml_data)
         valid_scores = ['observational', 'experimental']

doubleml/did/did_cs.py

@@ -49,10 +49,6 @@ class DoubleMLDIDCS(LinearScoreMixin, DoubleML):
         Indicates whether to use a sligthly different normalization from Sant'Anna and Zhao (2020).
         Default is ``True``.
 
-    dml_procedure : str
-        A str (``'dml1'`` or ``'dml2'``) specifying the double machine learning algorithm.
-        Default is ``'dml2'``.
-
     trimming_rule : str
         A str (``'truncate'`` is the only choice) specifying the trimming approach.
         Default is ``'truncate'``.
@@ -65,10 +61,6 @@ class DoubleMLDIDCS(LinearScoreMixin, DoubleML):
         Indicates whether the sample splitting should be drawn during initialization of the object.
         Default is ``True``.
 
-    apply_cross_fitting : bool
-        Indicates whether cross-fitting should be applied.
-        Default is ``True``.
-
     Examples
     --------
     >>> import numpy as np
@@ -93,18 +85,14 @@ def __init__(self,
                  n_rep=1,
                  score='observational',
                  in_sample_normalization=True,
-                 dml_procedure='dml2',
                  trimming_rule='truncate',
                  trimming_threshold=1e-2,
-                 draw_sample_splitting=True,
-                 apply_cross_fitting=True):
+                 draw_sample_splitting=True):
         super().__init__(obj_dml_data,
                          n_folds,
                          n_rep,
                          score,
-                         dml_procedure,
-                         draw_sample_splitting,
-                         apply_cross_fitting)
+                         draw_sample_splitting)
 
         self._check_data(self._dml_data)
         valid_scores = ['observational', 'experimental']

doubleml/did/tests/_utils_did_cs_manual.py

@@ -2,11 +2,11 @@
 from sklearn.base import clone
 
 from ...tests._utils import fit_predict, fit_predict_proba, tune_grid_search
-from ._utils_did_manual import did_dml1, did_dml2
+from ._utils_did_manual import did_dml2
 
 
 def fit_did_cs(y, x, d, t,
-               learner_g, learner_m, all_smpls, dml_procedure, score, in_sample_normalization,
+               learner_g, learner_m, all_smpls, score, in_sample_normalization,
                n_rep=1, g_d0_t0_params=None, g_d0_t1_params=None,
                g_d1_t0_params=None, g_d1_t1_params=None, m_params=None,
                trimming_threshold=1e-2):
@@ -57,11 +57,7 @@ def fit_did_cs(y, x, d, t,
         all_psi_a.append(psi_a)
         all_psi_b.append(psi_b)
 
-        if dml_procedure == 'dml1':
-            thetas[i_rep], ses[i_rep] = did_dml1(psi_a, psi_b, smpls)
-        else:
-            assert dml_procedure == 'dml2'
-            thetas[i_rep], ses[i_rep] = did_dml2(psi_a, psi_b)
+        thetas[i_rep], ses[i_rep] = did_dml2(psi_a, psi_b)
 
     theta = np.median(thetas)
     se = np.sqrt(np.median(np.power(ses, 2) * n_obs + np.power(thetas - theta, 2)) / n_obs)

doubleml/did/tests/_utils_did_manual.py

@@ -6,7 +6,7 @@
 
 
 def fit_did(y, x, d,
-            learner_g, learner_m, all_smpls, dml_procedure, score, in_sample_normalization,
+            learner_g, learner_m, all_smpls, score, in_sample_normalization,
             n_rep=1, g0_params=None, g1_params=None, m_params=None,
             trimming_threshold=1e-2):
     n_obs = len(y)
@@ -43,11 +43,7 @@ def fit_did(y, x, d,
         all_psi_a.append(psi_a)
         all_psi_b.append(psi_b)
 
-        if dml_procedure == 'dml1':
-            thetas[i_rep], ses[i_rep] = did_dml1(psi_a, psi_b, smpls)
-        else:
-            assert dml_procedure == 'dml2'
-            thetas[i_rep], ses[i_rep] = did_dml2(psi_a, psi_b)
+        thetas[i_rep], ses[i_rep] = did_dml2(psi_a, psi_b)
 
     theta = np.median(thetas)
     se = np.sqrt(np.median(np.power(ses, 2) * n_obs + np.power(thetas - theta, 2)) / n_obs)
@@ -107,25 +103,6 @@ def compute_did_residuals(y, g_hat0_list, g_hat1_list, m_hat_list, p_hat_list, s
     return resid_d0, g_hat0, g_hat1, m_hat, p_hat
 
 
-def did_dml1(psi_a, psi_b, smpls):
-    thetas = np.zeros(len(smpls))
-    n_obs = len(psi_a)
-
-    for idx, (_, test_index) in enumerate(smpls):
-        thetas[idx] = - np.mean(psi_b[test_index]) / np.mean(psi_a[test_index])
-    theta_hat = np.mean(thetas)
-
-    if len(smpls) > 1:
-        se = np.sqrt(var_did(theta_hat, psi_a, psi_b, n_obs))
-    else:
-        assert len(smpls) == 1
-        test_index = smpls[0][1]
-        n_obs = len(test_index)
-        se = np.sqrt(var_did(theta_hat, psi_a[test_index], psi_b[test_index], n_obs))
-
-    return theta_hat, se
-
-
 def did_dml2(psi_a, psi_b):
     n_obs = len(psi_a)
     theta_hat = - np.mean(psi_b) / np.mean(psi_a)
@@ -176,7 +153,6 @@ def var_did(theta, psi_a, psi_b, n_obs):
 
 def boot_did(y, thetas, ses, all_psi_a, all_psi_b,
              all_smpls, bootstrap, n_rep_boot, n_rep=1, apply_cross_fitting=True):
-    all_boot_theta = list()
     all_boot_t_stat = list()
     for i_rep in range(n_rep):
         smpls = all_smpls[i_rep]
@@ -186,16 +162,14 @@ def boot_did(y, thetas, ses, all_psi_a, all_psi_b,
             test_index = smpls[0][1]
             n_obs = len(test_index)
         weights = draw_weights(bootstrap, n_rep_boot, n_obs)
-        boot_theta, boot_t_stat = boot_did_single_split(
+        boot_t_stat = boot_did_single_split(
             thetas[i_rep], all_psi_a[i_rep], all_psi_b[i_rep], smpls,
             ses[i_rep], weights, n_rep_boot, apply_cross_fitting)
-        all_boot_theta.append(boot_theta)
         all_boot_t_stat.append(boot_t_stat)
 
-    boot_theta = np.hstack(all_boot_theta)
     boot_t_stat = np.hstack(all_boot_t_stat)
 
-    return boot_theta, boot_t_stat
+    return boot_t_stat
 
 
 def boot_did_single_split(theta, psi_a, psi_b,
@@ -208,9 +182,9 @@ def boot_did_single_split(theta, psi_a, psi_b,
         J = np.mean(psi_a[test_index])
 
     psi = np.multiply(psi_a, theta) + psi_b
-    boot_theta, boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot, apply_cross_fitting)
+    boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot, apply_cross_fitting)
 
-    return boot_theta, boot_t_stat
+    return boot_t_stat
 
 
 def tune_nuisance_did(y, x, d, ml_g, ml_m, smpls, score, n_folds_tune,

doubleml/did/tests/test_did.py

@@ -34,21 +34,14 @@ def in_sample_normalization(request):
     return request.param
 
 
-@pytest.fixture(scope='module',
-                params=['dml1', 'dml2'])
-def dml_procedure(request):
-    return request.param
-
-
 @pytest.fixture(scope='module',
                 params=[0.1])
 def trimming_threshold(request):
     return request.param
 
 
 @pytest.fixture(scope='module')
-def dml_did_fixture(generate_data_did, learner, score, in_sample_normalization,
-                    dml_procedure, trimming_threshold):
+def dml_did_fixture(generate_data_did, learner, score, in_sample_normalization, trimming_threshold):
     boot_methods = ['normal']
     n_folds = 2
     n_rep_boot = 499
@@ -71,7 +64,6 @@ def dml_did_fixture(generate_data_did, learner, score, in_sample_normalization,
                                   n_folds,
                                   score=score,
                                   in_sample_normalization=in_sample_normalization,
-                                  dml_procedure=dml_procedure,
                                   draw_sample_splitting=False,
                                   trimming_threshold=trimming_threshold)
 
@@ -82,7 +74,7 @@ def dml_did_fixture(generate_data_did, learner, score, in_sample_normalization,
     np.random.seed(3141)
     res_manual = fit_did(y, x, d,
                          clone(learner[0]), clone(learner[1]),
-                         all_smpls, dml_procedure, score, in_sample_normalization,
+                         all_smpls, score, in_sample_normalization,
                          trimming_threshold=trimming_threshold)
 
     res_dict = {'coef': dml_did_obj.coef,
@@ -93,15 +85,13 @@ def dml_did_fixture(generate_data_did, learner, score, in_sample_normalization,
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_did(y, res_manual['thetas'], res_manual['ses'],
-                                           res_manual['all_psi_a'], res_manual['all_psi_b'],
-                                           all_smpls, bootstrap, n_rep_boot)
+        boot_t_stat = boot_did(y, res_manual['thetas'], res_manual['ses'],
+                               res_manual['all_psi_a'], res_manual['all_psi_b'],
+                               all_smpls, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_did_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_did_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_did_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     # sensitivity tests
@@ -137,9 +127,6 @@ def test_dml_did_se(dml_did_fixture):
 @pytest.mark.ci
 def test_dml_did_boot(dml_did_fixture):
     for bootstrap in dml_did_fixture['boot_methods']:
-        assert np.allclose(dml_did_fixture['boot_coef' + bootstrap],
-                           dml_did_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_did_fixture['boot_t_stat' + bootstrap],
                            dml_did_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/did/tests/test_did_cs.py

@@ -35,21 +35,14 @@ def in_sample_normalization(request):
     return request.param
 
 
-@pytest.fixture(scope='module',
-                params=['dml1', 'dml2'])
-def dml_procedure(request):
-    return request.param
-
-
 @pytest.fixture(scope='module',
                 params=[0.1])
 def trimming_threshold(request):
     return request.param
 
 
 @pytest.fixture(scope='module')
-def dml_did_cs_fixture(generate_data_did_cs, learner, score, in_sample_normalization,
-                       dml_procedure, trimming_threshold):
+def dml_did_cs_fixture(generate_data_did_cs, learner, score, in_sample_normalization, trimming_threshold):
     boot_methods = ['normal']
     n_folds = 2
     n_rep_boot = 499
@@ -73,7 +66,6 @@ def dml_did_cs_fixture(generate_data_did_cs, learner, score, in_sample_normaliza
                                        n_folds,
                                        score=score,
                                        in_sample_normalization=in_sample_normalization,
-                                       dml_procedure=dml_procedure,
                                        draw_sample_splitting=False,
                                        trimming_threshold=trimming_threshold)
 
@@ -84,7 +76,7 @@ def dml_did_cs_fixture(generate_data_did_cs, learner, score, in_sample_normaliza
     np.random.seed(3141)
     res_manual = fit_did_cs(y, x, d, t,
                             clone(learner[0]), clone(learner[1]),
-                            all_smpls, dml_procedure, score, in_sample_normalization,
+                            all_smpls, score, in_sample_normalization,
                             trimming_threshold=trimming_threshold)
 
     res_dict = {'coef': dml_did_cs_obj.coef,
@@ -95,15 +87,13 @@ def dml_did_cs_fixture(generate_data_did_cs, learner, score, in_sample_normaliza
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_did(y, res_manual['thetas'], res_manual['ses'],
-                                           res_manual['all_psi_a'], res_manual['all_psi_b'],
-                                           all_smpls, bootstrap, n_rep_boot)
+        boot_t_stat = boot_did(y, res_manual['thetas'], res_manual['ses'],
+                               res_manual['all_psi_a'], res_manual['all_psi_b'],
+                               all_smpls, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_did_cs_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_did_cs_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_did_cs_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     # sensitivity tests
@@ -138,9 +128,6 @@ def test_dml_did_cs_se(dml_did_cs_fixture):
 @pytest.mark.ci
 def test_dml_did_cs_boot(dml_did_cs_fixture):
     for bootstrap in dml_did_cs_fixture['boot_methods']:
-        assert np.allclose(dml_did_cs_fixture['boot_coef' + bootstrap],
-                           dml_did_cs_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_did_cs_fixture['boot_t_stat' + bootstrap],
                            dml_did_cs_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/did/tests/test_didcs_external_predictions.py renamed to doubleml/did/tests/test_did_cs_external_predictions.py

@@ -13,18 +13,13 @@ def did_score(request):
     return request.param
 
 
-@pytest.fixture(scope="module", params=["dml1", "dml2"])
-def dml_procedure(request):
-    return request.param
-
-
 @pytest.fixture(scope="module", params=[1, 3])
 def n_rep(request):
     return request.param
 
 
 @pytest.fixture(scope="module")
-def doubleml_didcs_fixture(did_score, dml_procedure, n_rep):
+def doubleml_didcs_fixture(did_score, n_rep):
     ext_predictions = {"d": {}}
     dml_data = make_did_SZ2020(n_obs=500, cross_sectional_data=True, return_type="DoubleMLData")
     all_smpls = draw_smpls(len(dml_data.y), 5, n_rep=n_rep, groups=dml_data.d)
@@ -33,7 +28,6 @@ def doubleml_didcs_fixture(did_score, dml_procedure, n_rep):
         "score": did_score,
         "n_rep": n_rep,
         "n_folds": 5,
-        "dml_procedure": dml_procedure,
         "draw_sample_splitting": False
     }
     dml_did_cs = DoubleMLDIDCS(ml_g=LinearRegression(), ml_m=LogisticRegression(), **kwargs)