remove boot_coefs from plm tests

Author: SvenKlaassen

doubleml/plm/tests/_utils_pliv_manual.py

@@ -149,7 +149,6 @@ def pliv_orth(y_minus_l_hat, z_minus_m_hat, d_minus_r_hat, y_minus_g_hat, d, sco
 def boot_pliv(y, d, z, thetas, ses, all_l_hat, all_m_hat, all_r_hat, all_g_hat,
               all_smpls, score, 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]
@@ -159,16 +158,14 @@ def boot_pliv(y, d, z, thetas, ses, all_l_hat, all_m_hat, all_r_hat, all_g_hat,
             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_pliv_single_split(
+        boot_t_stat = boot_pliv_single_split(
             thetas[i_rep], y, d, z, all_l_hat[i_rep], all_m_hat[i_rep], all_r_hat[i_rep], all_g_hat[i_rep], smpls,
             score, 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_pliv_single_split(theta, y, d, z, l_hat, m_hat, r_hat, g_hat,
@@ -196,6 +193,6 @@ def boot_pliv_single_split(theta, y, d, z, l_hat, m_hat, r_hat, g_hat,
         assert score == 'IV-type'
         psi = np.multiply(y_minus_g_hat - d*theta, z_minus_m_hat)
 
-    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

doubleml/plm/tests/_utils_pliv_partial_x_manual.py

@@ -120,21 +120,18 @@ def pliv_partial_x_orth(u_hat, w_hat, r_hat_tilde, d, score):
 def boot_pliv_partial_x(y, d, z, thetas, ses, all_l_hat, all_m_hat, all_r_hat,
                         all_smpls, score, bootstrap, n_rep_boot,
                         n_rep=1):
-    all_boot_theta = list()
     all_boot_t_stat = list()
     for i_rep in range(n_rep):
         n_obs = len(y)
         weights = draw_weights(bootstrap, n_rep_boot, n_obs)
-        boot_theta, boot_t_stat = boot_pliv_partial_x_single_split(
+        boot_t_stat = boot_pliv_partial_x_single_split(
             thetas[i_rep], y, d, z, all_l_hat[i_rep], all_m_hat[i_rep], all_r_hat[i_rep], all_smpls[i_rep],
             score, ses[i_rep], weights, n_rep_boot)
-        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_pliv_partial_x_single_split(theta, y, d, z, l_hat, r_hat, r_hat_tilde,
@@ -146,6 +143,6 @@ def boot_pliv_partial_x_single_split(theta, y, d, z, l_hat, r_hat, r_hat_tilde,
 
     psi = np.multiply(u_hat - w_hat*theta, r_hat_tilde)
 
-    boot_theta, boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot)
+    boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot)
 
-    return boot_theta, boot_t_stat
+    return boot_t_stat

doubleml/plm/tests/_utils_pliv_partial_xz_manual.py

@@ -124,21 +124,18 @@ def pliv_partial_xz_orth(u_hat, v_hat, w_hat, d, score):
 def boot_pliv_partial_xz(y, d, z, thetas, ses, all_l_hat, all_m_hat, all_r_hat,
                          all_smpls, score, bootstrap, n_rep_boot,
                          n_rep=1):
-    all_boot_theta = list()
     all_boot_t_stat = list()
     for i_rep in range(n_rep):
         n_obs = len(y)
         weights = draw_weights(bootstrap, n_rep_boot, n_obs)
-        boot_theta, boot_t_stat = boot_pliv_partial_xz_single_split(
+        boot_t_stat = boot_pliv_partial_xz_single_split(
             thetas[i_rep], y, d, z, all_l_hat[i_rep], all_m_hat[i_rep], all_r_hat[i_rep], all_smpls[i_rep],
             score, ses[i_rep], weights, n_rep_boot)
-        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_pliv_partial_xz_single_split(theta, y, d, z, l_hat, m_hat, m_hat_tilde,
@@ -150,6 +147,6 @@ def boot_pliv_partial_xz_single_split(theta, y, d, z, l_hat, m_hat, m_hat_tilde,
 
     psi = np.multiply(u_hat - w_hat*theta, v_hat)
 
-    boot_theta, boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot)
+    boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot)
 
-    return boot_theta, boot_t_stat
+    return boot_t_stat

doubleml/plm/tests/_utils_pliv_partial_z_manual.py

@@ -86,21 +86,18 @@ def pliv_partial_z_orth(r_hat, y, d, score):
 def boot_pliv_partial_z(y, d, z, thetas, ses, all_r_hat,
                         all_smpls, score, bootstrap, n_rep_boot,
                         n_rep=1):
-    all_boot_theta = list()
     all_boot_t_stat = list()
     for i_rep in range(n_rep):
         n_obs = len(y)
         weights = draw_weights(bootstrap, n_rep_boot, n_obs)
-        boot_theta, boot_t_stat = boot_pliv_partial_z_single_split(
+        boot_t_stat = boot_pliv_partial_z_single_split(
             thetas[i_rep], y, d, z, all_r_hat[i_rep], all_smpls[i_rep],
             score, ses[i_rep], weights, n_rep_boot)
-        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_pliv_partial_z_single_split(theta, y, d, z, r_hat,
@@ -112,6 +109,6 @@ def boot_pliv_partial_z_single_split(theta, y, d, z, r_hat,
 
     psi = np.multiply(y - d*theta, r_hat_array)
 
-    boot_theta, boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot)
+    boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep_boot)
 
-    return boot_theta, boot_t_stat
+    return boot_t_stat

doubleml/plm/tests/_utils_plr_manual.py

@@ -227,7 +227,6 @@ def plr_orth(y_minus_l_hat, d_minus_m_hat, y_minus_g_hat, d, score):
 def boot_plr(y, d, thetas, ses, all_l_hat, all_m_hat, all_g_hat,
              all_smpls, score, 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]
@@ -238,24 +237,21 @@ def boot_plr(y, d, thetas, ses, all_l_hat, all_m_hat, all_g_hat,
             n_obs = len(test_index)
         weights = draw_weights(bootstrap, n_rep_boot, n_obs)
 
-        boot_theta, boot_t_stat = boot_plr_single_split(
+        boot_t_stat = boot_plr_single_split(
             thetas[i_rep], y, d, all_l_hat[i_rep], all_m_hat[i_rep], all_g_hat[i_rep], smpls,
             score, 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_plr_multitreat(y, d, thetas, ses, all_l_hat, all_m_hat, all_g_hat,
                         all_smpls, score, bootstrap, n_rep_boot,
                         n_rep=1, apply_cross_fitting=True):
     n_d = d.shape[1]
-    all_boot_theta = list()
     all_boot_t_stat = list()
     for i_rep in range(n_rep):
         smpls = all_smpls[i_rep]
@@ -266,21 +262,18 @@ def boot_plr_multitreat(y, d, thetas, ses, all_l_hat, all_m_hat, all_g_hat,
             n_obs = len(test_index)
         weights = draw_weights(bootstrap, n_rep_boot, n_obs)
 
-        boot_theta = np.full((n_d, n_rep_boot), np.nan)
         boot_t_stat = np.full((n_d, n_rep_boot), np.nan)
         for i_d in range(n_d):
-            boot_theta[i_d, :], boot_t_stat[i_d, :] = boot_plr_single_split(
+            boot_t_stat[i_d, :] = boot_plr_single_split(
                 thetas[i_rep][i_d], y, d[:, i_d],
                 all_l_hat[i_rep][i_d], all_m_hat[i_rep][i_d], all_g_hat[i_rep][i_d],
                 smpls, score, ses[i_rep][i_d],
                 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_plr_single_split(theta, y, d, l_hat, m_hat, g_hat,
@@ -307,9 +300,9 @@ def boot_plr_single_split(theta, y, d, l_hat, m_hat, g_hat,
         assert score == 'IV-type'
         psi = np.multiply(y_minus_g_hat - d * theta, d_minus_m_hat)
 
-    boot_theta, boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep, apply_cross_fitting)
+    boot_t_stat = boot_manual(psi, J, smpls, se, weights, n_rep, apply_cross_fitting)
 
-    return boot_theta, boot_t_stat
+    return boot_t_stat
 
 
 def fit_sensitivity_elements_plr(y, d, all_coef, predictions, score, n_rep):

doubleml/plm/tests/test_pliv.py

@@ -79,16 +79,14 @@ def dml_pliv_fixture(generate_data_iv, learner, score):
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_pliv(y, d, z, res_manual['thetas'], res_manual['ses'],
-                                            res_manual['all_l_hat'], res_manual['all_m_hat'], res_manual['all_r_hat'],
-                                            res_manual['all_g_hat'],
-                                            all_smpls, score, bootstrap, n_rep_boot)
+        boot_t_stat = boot_pliv(y, d, z, res_manual['thetas'], res_manual['ses'],
+                                res_manual['all_l_hat'], res_manual['all_m_hat'], res_manual['all_r_hat'],
+                                res_manual['all_g_hat'],
+                                all_smpls, score, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_pliv_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_pliv_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_pliv_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     return res_dict
@@ -111,9 +109,6 @@ def test_dml_pliv_se(dml_pliv_fixture):
 @pytest.mark.ci
 def test_dml_pliv_boot(dml_pliv_fixture):
     for bootstrap in dml_pliv_fixture['boot_methods']:
-        assert np.allclose(dml_pliv_fixture['boot_coef' + bootstrap],
-                           dml_pliv_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_pliv_fixture['boot_t_stat' + bootstrap],
                            dml_pliv_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/plm/tests/test_pliv_partial_x.py

@@ -65,16 +65,15 @@ def dml_pliv_partial_x_fixture(generate_data_pliv_partialX, learner, score):
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_pliv_partial_x(y, d, z, res_manual['thetas'], res_manual['ses'],
-                                                      res_manual['all_l_hat'], res_manual['all_m_hat'],
-                                                      res_manual['all_r_hat'],
-                                                      all_smpls, score, bootstrap, n_rep_boot)
+        boot_t_stat = boot_pliv_partial_x(y, d, z, res_manual['thetas'], res_manual['ses'],
+                                          res_manual['all_l_hat'], res_manual['all_m_hat'],
+                                          res_manual['all_r_hat'],
+                                          all_smpls, score, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_pliv_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_pliv_obj.boot_coef
+
         res_dict['boot_t_stat' + bootstrap] = dml_pliv_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     return res_dict
@@ -94,9 +93,6 @@ def test_dml_pliv_se(dml_pliv_partial_x_fixture):
 
 def test_dml_pliv_boot(dml_pliv_partial_x_fixture):
     for bootstrap in dml_pliv_partial_x_fixture['boot_methods']:
-        assert np.allclose(dml_pliv_partial_x_fixture['boot_coef' + bootstrap],
-                           dml_pliv_partial_x_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_pliv_partial_x_fixture['boot_t_stat' + bootstrap],
                            dml_pliv_partial_x_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/plm/tests/test_pliv_partial_x_tune.py

@@ -127,16 +127,14 @@ def dml_pliv_partial_x_fixture(generate_data_pliv_partialX, learner_l, learner_m
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_pliv_partial_x(y, d, z, res_manual['thetas'], res_manual['ses'],
-                                                      res_manual['all_l_hat'], res_manual['all_m_hat'],
-                                                      res_manual['all_r_hat'],
-                                                      all_smpls, score, bootstrap, n_rep_boot)
+        boot_t_stat = boot_pliv_partial_x(y, d, z, res_manual['thetas'], res_manual['ses'],
+                                          res_manual['all_l_hat'], res_manual['all_m_hat'],
+                                          res_manual['all_r_hat'],
+                                          all_smpls, score, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_pliv_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_pliv_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_pliv_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     return res_dict
@@ -156,9 +154,6 @@ def test_dml_pliv_se(dml_pliv_partial_x_fixture):
 
 def test_dml_pliv_boot(dml_pliv_partial_x_fixture):
     for bootstrap in dml_pliv_partial_x_fixture['boot_methods']:
-        assert np.allclose(dml_pliv_partial_x_fixture['boot_coef' + bootstrap],
-                           dml_pliv_partial_x_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_pliv_partial_x_fixture['boot_t_stat' + bootstrap],
                            dml_pliv_partial_x_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/plm/tests/test_pliv_partial_xz.py

@@ -65,16 +65,14 @@ def dml_pliv_partial_xz_fixture(generate_data_pliv_partialXZ, learner, score):
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_pliv_partial_xz(y, d, z, res_manual['thetas'], res_manual['ses'],
-                                                       res_manual['all_l_hat'], res_manual['all_m_hat'],
-                                                       res_manual['all_r_hat'],
-                                                       all_smpls, score, bootstrap, n_rep_boot)
+        boot_t_stat = boot_pliv_partial_xz(y, d, z, res_manual['thetas'], res_manual['ses'],
+                                           res_manual['all_l_hat'], res_manual['all_m_hat'],
+                                           res_manual['all_r_hat'],
+                                           all_smpls, score, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_pliv_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_pliv_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_pliv_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     return res_dict
@@ -94,9 +92,6 @@ def test_dml_pliv_se(dml_pliv_partial_xz_fixture):
 
 def test_dml_pliv_boot(dml_pliv_partial_xz_fixture):
     for bootstrap in dml_pliv_partial_xz_fixture['boot_methods']:
-        assert np.allclose(dml_pliv_partial_xz_fixture['boot_coef' + bootstrap],
-                           dml_pliv_partial_xz_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_pliv_partial_xz_fixture['boot_t_stat' + bootstrap],
                            dml_pliv_partial_xz_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/plm/tests/test_pliv_partial_xz_tune.py

@@ -127,16 +127,14 @@ def dml_pliv_partial_xz_fixture(generate_data_pliv_partialXZ, learner_l, learner
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_pliv_partial_xz(y, d, z, res_manual['thetas'], res_manual['ses'],
-                                                       res_manual['all_l_hat'], res_manual['all_m_hat'],
-                                                       res_manual['all_r_hat'],
-                                                       all_smpls, score, bootstrap, n_rep_boot)
+        boot_t_stat = boot_pliv_partial_xz(y, d, z, res_manual['thetas'], res_manual['ses'],
+                                           res_manual['all_l_hat'], res_manual['all_m_hat'],
+                                           res_manual['all_r_hat'],
+                                           all_smpls, score, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_pliv_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_pliv_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_pliv_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     return res_dict
@@ -156,9 +154,6 @@ def test_dml_pliv_se(dml_pliv_partial_xz_fixture):
 
 def test_dml_pliv_boot(dml_pliv_partial_xz_fixture):
     for bootstrap in dml_pliv_partial_xz_fixture['boot_methods']:
-        assert np.allclose(dml_pliv_partial_xz_fixture['boot_coef' + bootstrap],
-                           dml_pliv_partial_xz_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_pliv_partial_xz_fixture['boot_t_stat' + bootstrap],
                            dml_pliv_partial_xz_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)

doubleml/plm/tests/test_pliv_partial_z.py

@@ -66,15 +66,13 @@ def dml_pliv_partial_z_fixture(generate_data_pliv_partialZ, learner, score):
 
     for bootstrap in boot_methods:
         np.random.seed(3141)
-        boot_theta, boot_t_stat = boot_pliv_partial_z(y, d, z, res_manual['thetas'], res_manual['ses'],
-                                                      res_manual['all_r_hat'],
-                                                      all_smpls, score, bootstrap, n_rep_boot)
+        boot_t_stat = boot_pliv_partial_z(y, d, z, res_manual['thetas'], res_manual['ses'],
+                                          res_manual['all_r_hat'],
+                                          all_smpls, score, bootstrap, n_rep_boot)
 
         np.random.seed(3141)
         dml_pliv_obj.bootstrap(method=bootstrap, n_rep_boot=n_rep_boot)
-        res_dict['boot_coef' + bootstrap] = dml_pliv_obj.boot_coef
         res_dict['boot_t_stat' + bootstrap] = dml_pliv_obj.boot_t_stat
-        res_dict['boot_coef' + bootstrap + '_manual'] = boot_theta
         res_dict['boot_t_stat' + bootstrap + '_manual'] = boot_t_stat
 
     return res_dict
@@ -94,9 +92,6 @@ def test_dml_pliv_se(dml_pliv_partial_z_fixture):
 
 def test_dml_pliv_boot(dml_pliv_partial_z_fixture):
     for bootstrap in dml_pliv_partial_z_fixture['boot_methods']:
-        assert np.allclose(dml_pliv_partial_z_fixture['boot_coef' + bootstrap],
-                           dml_pliv_partial_z_fixture['boot_coef' + bootstrap + '_manual'],
-                           rtol=1e-9, atol=1e-4)
         assert np.allclose(dml_pliv_partial_z_fixture['boot_t_stat' + bootstrap],
                            dml_pliv_partial_z_fixture['boot_t_stat' + bootstrap + '_manual'],
                            rtol=1e-9, atol=1e-4)