drdid 1.1.6__py3-none-any.whl

drdid/_version_.py

@@ -0,0 +1 @@
+version = '1.1.6'

drdid/drdid.py

@@ -0,0 +1,275 @@
+import numpy as np
+from numpy import ndarray
+import statsmodels.api as sm
+from .utils import *
+
+import numpy as np
+import statsmodels.api as sm
+def drdid_rc(y, post, D, covariates, i_weights=None):
+
+    # Convert inputs to numpy arrays
+    D = np.asarray(D).flatten()
+    n = len(D)
+    y = np.asarray(y).flatten()
+    post = np.asarray(post).flatten()
+    
+    # Add constant to covariate matrix
+    if covariates is None:
+        int_cov = np.ones((n, 1))
+    else:
+        covariates = np.asarray(covariates)
+        if np.all(covariates[:, 0] == 1):
+            int_cov = covariates
+        else:
+            int_cov = np.column_stack((np.ones(n), covariates))
+    
+    # Normalize weights
+    if i_weights is None:
+        i_weights = np.ones(n)
+    i_weights = np.asanyarray(i_weights).flatten()
+    i_weights = i_weights / np.mean(i_weights)
+    
+    # Compute the Pscore by MLE
+    pscore_model = sm.GLM(D, int_cov, family=sm.families.Binomial(), freq_weights=i_weights)
+    pscore_results = pscore_model.fit()
+    if not pscore_results.converged:
+        print("Warning: glm algorithm did not converge")
+    if np.any(np.isnan(pscore_results.params)):
+        raise ValueError("Propensity score model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    ps_fit = pscore_results.predict()
+    ps_fit = np.minimum(ps_fit, 1 - 1e-16)
+    
+    # Compute the Outcome regression for the control group at the pre-treatment period
+    mask_cont_pre = (D == 0) & (post == 0)
+    reg_cont_pre = sm.WLS(y[mask_cont_pre], int_cov[mask_cont_pre], weights=i_weights[mask_cont_pre]).fit()
+    if np.any(np.isnan(reg_cont_pre.params)):
+        raise ValueError("Outcome regression model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    out_y_cont_pre = np.dot(int_cov, reg_cont_pre.params)
+    
+    # Compute the Outcome regression for the control group at the post-treatment period
+    mask_cont_post = (D == 0) & (post == 1)
+    reg_cont_post = sm.WLS(y[mask_cont_post], int_cov[mask_cont_post], weights=i_weights[mask_cont_post]).fit()
+    if np.any(np.isnan(reg_cont_post.params)):
+        raise ValueError("Outcome regression model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    out_y_cont_post = np.dot(int_cov, reg_cont_post.params)
+    
+    # Combine the ORs for control group
+    out_y_cont = post * out_y_cont_post + (1 - post) * out_y_cont_pre
+    
+    # Compute the Outcome regression for the treated group at the pre-treatment period
+    mask_treat_pre = (D == 1) & (post == 0)
+    reg_treat_pre = sm.WLS(y[mask_treat_pre], int_cov[mask_treat_pre], weights=i_weights[mask_treat_pre]).fit()
+    out_y_treat_pre = np.dot(int_cov, reg_treat_pre.params)
+    
+    # Compute the Outcome regression for the treated group at the post-treatment period
+    mask_treat_post = (D == 1) & (post == 1)
+    reg_treat_post = sm.WLS(y[mask_treat_post], int_cov[mask_treat_post], weights=i_weights[mask_treat_post]).fit()
+    out_y_treat_post = np.dot(int_cov, reg_treat_post.params)
+    
+    # Compute weights
+    w_treat_pre = i_weights * D * (1 - post)
+    w_treat_post = i_weights * D * post
+    w_cont_pre = i_weights * ps_fit * (1 - D) * (1 - post) / (1 - ps_fit)
+    w_cont_post = i_weights * ps_fit * (1 - D) * post / (1 - ps_fit)
+    w_d = i_weights * D
+    w_dt1 = i_weights * D * post
+    w_dt0 = i_weights * D * (1 - post)
+    
+    # Elements of the influence function (summands)
+    eta_treat_pre = w_treat_pre * (y - out_y_cont) / np.mean(w_treat_pre)
+    eta_treat_post = w_treat_post * (y - out_y_cont) / np.mean(w_treat_post)
+    eta_cont_pre = w_cont_pre * (y - out_y_cont) / np.mean(w_cont_pre)
+    eta_cont_post = w_cont_post * (y - out_y_cont) / np.mean(w_cont_post)
+    
+    # Extra elements for the locally efficient DRDID
+    eta_d_post = w_d * (out_y_treat_post - out_y_cont_post) / np.mean(w_d)
+    eta_dt1_post = w_dt1 * (out_y_treat_post - out_y_cont_post) / np.mean(w_dt1)
+    eta_d_pre = w_d * (out_y_treat_pre - out_y_cont_pre) / np.mean(w_d)
+    eta_dt0_pre = w_dt0 * (out_y_treat_pre - out_y_cont_pre) / np.mean(w_dt0)
+    
+    # Estimator of each component
+    att_treat_pre = np.mean(eta_treat_pre)
+    att_treat_post = np.mean(eta_treat_post)
+    att_cont_pre = np.mean(eta_cont_pre)
+    att_cont_post = np.mean(eta_cont_post)
+    att_d_post = np.mean(eta_d_post)
+    att_dt1_post = np.mean(eta_dt1_post)
+    att_d_pre = np.mean(eta_d_pre)
+    att_dt0_pre = np.mean(eta_dt0_pre)
+    
+    # ATT estimator
+    dr_att = (att_treat_post - att_treat_pre) - (att_cont_post - att_cont_pre) + \
+             (att_d_post - att_dt1_post) - (att_d_pre - att_dt0_pre)
+    
+    # Compute influence functions
+    weights_ols_pre = i_weights * (1 - D) * (1 - post)
+    weights_ols_pre = np.array(weights_ols_pre)
+    wols_x_pre = weights_ols_pre[:, np.newaxis] * int_cov
+    wols_eX_pre = weights_ols_pre[:, np.newaxis] * (y - out_y_cont_pre)[:, np.newaxis] * int_cov
+    XpX_inv_pre = np.linalg.inv(np.dot(wols_x_pre.T, int_cov) / n)
+    asy_lin_rep_ols_pre = np.dot(wols_eX_pre, XpX_inv_pre)
+    
+    weights_ols_post = i_weights * (1 - D) * post
+    
+    wols_x_post = weights_ols_post[:, np.newaxis] * int_cov
+    wols_eX_post = weights_ols_post[:, np.newaxis] * (y - out_y_cont_post)[:, np.newaxis] * int_cov
+    XpX_inv_post = np.linalg.inv(np.dot(wols_x_post.T, int_cov) / n)
+    asy_lin_rep_ols_post = np.dot(wols_eX_post, XpX_inv_post)
+    
+    weights_ols_pre_treat = i_weights * D * (1 - post)
+    wols_x_pre_treat = weights_ols_pre_treat[:, np.newaxis] * int_cov
+    wols_eX_pre_treat = weights_ols_pre_treat[:, np.newaxis] * (y - out_y_treat_pre)[:, np.newaxis] * int_cov
+    XpX_inv_pre_treat = np.linalg.inv(np.dot(wols_x_pre_treat.T, int_cov) / n)
+    asy_lin_rep_ols_pre_treat = np.dot(wols_eX_pre_treat, XpX_inv_pre_treat)
+    
+    weights_ols_post_treat = i_weights * D * post
+    wols_x_post_treat = weights_ols_post_treat[:, np.newaxis] * int_cov
+    wols_eX_post_treat = weights_ols_post_treat[:, np.newaxis] * (y - out_y_treat_post)[:, np.newaxis] * int_cov
+    XpX_inv_post_treat = np.linalg.inv(np.dot(wols_x_post_treat.T, int_cov) / n)
+    asy_lin_rep_ols_post_treat = np.dot(wols_eX_post_treat, XpX_inv_post_treat)
+    
+    score_ps = i_weights[:, np.newaxis] * (D - ps_fit)[:, np.newaxis] * int_cov
+    Hessian_ps = pscore_results.cov_params() * n
+    asy_lin_rep_ps = np.dot(score_ps, Hessian_ps)
+    
+    # Influence function components
+    inf_treat_pre = eta_treat_pre - w_treat_pre * att_treat_pre / np.mean(w_treat_pre)
+    inf_treat_post = eta_treat_post - w_treat_post * att_treat_post / np.mean(w_treat_post)
+    
+    M1_post = -np.mean(w_treat_post[:, np.newaxis] * post[:, np.newaxis] * int_cov, axis=0) / np.mean(w_treat_post)
+    M1_pre = -np.mean(w_treat_pre[:, np.newaxis] * (1 - post)[:, np.newaxis] * int_cov, axis=0) / np.mean(w_treat_pre)
+    
+    inf_treat_or_post = np.dot(asy_lin_rep_ols_post, M1_post)
+    inf_treat_or_pre = np.dot(asy_lin_rep_ols_pre, M1_pre)
+    inf_treat_or = inf_treat_or_post + inf_treat_or_pre
+    
+    inf_treat = inf_treat_post - inf_treat_pre + inf_treat_or
+    
+    inf_cont_pre = eta_cont_pre - w_cont_pre * att_cont_pre / np.mean(w_cont_pre)
+    inf_cont_post = eta_cont_post - w_cont_post * att_cont_post / np.mean(w_cont_post)
+    
+    M2_pre = np.mean(w_cont_pre[:, np.newaxis] * (y - out_y_cont - att_cont_pre)[:, np.newaxis] * int_cov, axis=0) / np.mean(w_cont_pre)
+    M2_post = np.mean(w_cont_post[:, np.newaxis] * (y - out_y_cont - att_cont_post)[:, np.newaxis] * int_cov, axis=0) / np.mean(w_cont_post)
+    
+    inf_cont_ps = np.dot(asy_lin_rep_ps, M2_post - M2_pre)
+    
+    M3_post = -np.mean(w_cont_post[:, np.newaxis] * post[:, np.newaxis] * int_cov, axis=0) / np.mean(w_cont_post)
+    M3_pre = -np.mean(w_cont_pre[:, np.newaxis] * (1 - post)[:, np.newaxis] * int_cov, axis=0) / np.mean(w_cont_pre)
+    
+    inf_cont_or_post = np.dot(asy_lin_rep_ols_post, M3_post)
+    inf_cont_or_pre = np.dot(asy_lin_rep_ols_pre, M3_pre)
+    inf_cont_or = inf_cont_or_post + inf_cont_or_pre
+    
+    inf_cont = inf_cont_post - inf_cont_pre + inf_cont_ps + inf_cont_or
+    
+    dr_att_inf_func1 = inf_treat - inf_cont
+    
+    inf_eff1 = eta_d_post - w_d * att_d_post / np.mean(w_d)
+    inf_eff2 = eta_dt1_post - w_dt1 * att_dt1_post / np.mean(w_dt1)
+    inf_eff3 = eta_d_pre - w_d * att_d_pre / np.mean(w_d)
+    inf_eff4 = eta_dt0_pre - w_dt0 * att_dt0_pre / np.mean(w_dt0)
+    inf_eff = (inf_eff1 - inf_eff2) - (inf_eff3 - inf_eff4)
+    
+    mom_post = np.mean((w_d[:, np.newaxis] / np.mean(w_d) - w_dt1[:, np.newaxis] / np.mean(w_dt1)) * int_cov, axis=0)
+    mom_pre = np.mean((w_d[:, np.newaxis] / np.mean(w_d) - w_dt0[:, np.newaxis] / np.mean(w_dt0)) * int_cov, axis=0)
+    inf_or_post = np.dot(asy_lin_rep_ols_post_treat - asy_lin_rep_ols_post, mom_post)
+    inf_or_pre = np.dot(asy_lin_rep_ols_pre_treat - asy_lin_rep_ols_pre, mom_pre)
+    inf_or = inf_or_post - inf_or_pre
+    
+    dr_att_inf_func = dr_att_inf_func1 + inf_eff + inf_or
+    se = np.std(dr_att_inf_func, ddof=1) / np.sqrt(n)
+    #print(f"att: {dr_att} \t se: {se}")
+    return dr_att, dr_att_inf_func
+
+
+
+def drdid_panel(y1, y0, D, covariates, i_weights=None):
+
+    # Convert inputs to numpy arrays
+    D = np.asarray(D).flatten()
+    n = len(D)
+    deltaY = np.asarray(y1 - y0).flatten()
+    i_weights = np.asarray(i_weights).flatten()
+    
+    # Add constant to covariate matrix
+    if covariates is None:
+        int_cov = np.ones((n, 1))
+    else:
+        covariates = np.asarray(covariates)
+        if np.all(covariates[:, 0] == 1):
+            int_cov = covariates
+        else:
+            int_cov = np.column_stack((np.ones(n), covariates))
+    
+    # Weights
+    if i_weights is None:
+        i_weights = np.ones(n)
+    elif np.min(i_weights) < 0:
+        raise ValueError("i_weights must be non-negative")
+    
+    # Normalize weights
+    i_weights = i_weights / np.mean(i_weights)
+    # print(D.mean())
+    
+    # Compute the Pscore by MLE
+    pscore_model = sm.GLM(D, int_cov, family=sm.families.Binomial(), freq_weights=i_weights)
+    pscore_results = pscore_model.fit()
+    # print(D.mean())
+    # print(pscore_results.summary2())
+    if not pscore_results.converged:
+        print("Warning: glm algorithm did not converge")
+    if np.any(np.isnan(pscore_results.params)):
+        raise ValueError("Propensity score model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    ps_fit = pscore_results.predict()
+    ps_fit = np.minimum(ps_fit, 1 - 1e-16)
+    # print(ps_fit)
+    
+    # Compute the Outcome regression for the control group using wols
+    mask = D == 0
+    reg_model = sm.WLS(deltaY[mask], int_cov[mask], weights=i_weights[mask])
+    reg_results = reg_model.fit()
+    if np.any(np.isnan(reg_results.params)):
+        raise ValueError("Outcome regression model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    out_delta = np.dot(int_cov, reg_results.params)
+    
+    # Compute Traditional Doubly Robust DiD estimators
+    w_treat = i_weights * D
+    w_cont = i_weights * ps_fit * (1 - D) / (1 - ps_fit)
+    dr_att_treat = w_treat * (deltaY - out_delta)
+    dr_att_cont = w_cont * (deltaY - out_delta)
+    
+    eta_treat = np.mean(dr_att_treat) / np.mean(w_treat)
+    eta_cont = np.mean(dr_att_cont) / np.mean(w_cont)
+    
+    dr_att = eta_treat - eta_cont
+    
+    # Compute influence function
+    weights_ols = i_weights * (1 - D)
+    wols_x = weights_ols[:, np.newaxis] * int_cov
+    wols_eX = weights_ols[:, np.newaxis] * (deltaY - out_delta)[:, np.newaxis] * int_cov
+    XpX_inv = np.linalg.inv(np.dot(wols_x.T, int_cov) / n)
+    asy_lin_rep_wols = np.dot(wols_eX, XpX_inv)
+    
+    score_ps = i_weights[:, np.newaxis] * (D - ps_fit)[:, np.newaxis] * int_cov
+    Hessian_ps = pscore_results.cov_params() * n
+    asy_lin_rep_ps = np.dot(score_ps, Hessian_ps)
+    
+    inf_treat_1 = dr_att_treat - w_treat * eta_treat
+    M1 = np.mean(w_treat[:, np.newaxis] * int_cov, axis=0)
+    inf_treat_2 = np.dot(asy_lin_rep_wols, M1)
+    inf_treat = (inf_treat_1 - inf_treat_2) / np.mean(w_treat)
+    
+    inf_cont_1 = dr_att_cont - w_cont * eta_cont
+    M2 = np.mean(w_cont[:, np.newaxis] * (deltaY - out_delta - eta_cont)[:, np.newaxis] * int_cov, axis=0)
+    inf_cont_2 = np.dot(asy_lin_rep_ps, M2)
+    M3 = np.mean(w_cont[:, np.newaxis] * int_cov, axis=0)
+    inf_cont_3 = np.dot(asy_lin_rep_wols, M3)
+    inf_control = (inf_cont_1 + inf_cont_2 - inf_cont_3) / np.mean(w_cont)
+    
+    dr_att_inf_func = inf_treat - inf_control
+    se = np.std(dr_att_inf_func, ddof=1) / np.sqrt(n)
+    # print(f"att: {dr_att} \t se: {se}")    
+    return dr_att, dr_att_inf_func
+
+
+  

drdid/ipwd_did.py

@@ -0,0 +1,160 @@
+from .utils import *
+
+def std_ipw_did_panel(y1, y0, D, covariates, i_weights = None):
+    # print("ipw: panel")
+    D = np.asarray(D).flatten()
+    n = len(D)
+    delta_y = np.asarray(y1 - y0).flatten()
+    int_cov = np.ones((n, 1))
+    i_weights = np.asarray(i_weights).flatten()
+    if covariates is not None:
+        covariates = np.asarray(covariates)
+        if np.all(covariates[:, 0] == 1):
+            int_cov = covariates
+        else:
+            int_cov = np.column_stack((np.ones(n), covariates))
+    
+    if i_weights is None:
+        i_weights = np.ones(n)
+    elif np.min(i_weights) < 0:
+        raise ValueError("i_weights must be non-negative")
+    
+    i_weights = i_weights / np.mean(i_weights)
+    pscore_model = sm.GLM(D, int_cov, family=sm.families.Binomial(), freq_weights=i_weights)
+    pscore_results = pscore_model.fit()
+    # print(D.mean())
+    # print(pscore_results.summary2())
+    if not pscore_results.converged:
+        print("Warning: glm algorithm did not converge")
+    if np.any(np.isnan(pscore_results.params)):
+        raise ValueError("Propensity score model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    ps_fit = pscore_results.predict()
+    ps_fit = np.minimum(ps_fit, 1 - 1e-16)
+
+    w_treat = i_weights * D
+    w_cont = i_weights * ps_fit * (1 - D) / (1 - ps_fit)
+    
+    att_treat = w_treat * delta_y
+    att_cont = w_cont * delta_y
+
+    eta_treat = mean(att_treat) / mean(w_treat)
+    eta_cont = mean(att_cont) / mean(w_cont)
+
+    ipw_att = eta_treat - eta_cont
+
+    score_ps = i_weights[:, np.newaxis] * (D - ps_fit)[:, np.newaxis] * int_cov
+    Hessian_ps = pscore_results.cov_params() * n
+    asy_lin_rep_ps = np.dot(score_ps, Hessian_ps)
+
+    inf_treat = (att_treat - w_treat * eta_treat) / mean(w_treat)
+    inf_cont_1 = att_cont - w_cont * eta_cont
+    pre_m2 = w_cont * (delta_y - eta_cont)
+    M2 = np.mean(pre_m2[:, np.newaxis] * int_cov, axis = 0)
+    # print(M2)
+    inf_cont_2 = np.dot(asy_lin_rep_ps, M2)
+
+    inf_control = (inf_cont_1 + inf_cont_2) / np.mean(w_cont)
+    att_inf_func = inf_treat - inf_control
+    se = np.std(att_inf_func, ddof=1) / np.sqrt(n)
+    # print(f"att: {ipw_att} \t se: {se}")    
+    # print(np.std(att_inf_func) / np.sqrt(n))
+    return ipw_att, att_inf_func
+
+def std_ipw_did_rc(y, post, D, covariates, i_weights = None):
+    # print("ipw: rc")
+    D = np.asarray(D).flatten()
+    y = np.asarray(y).flatten()
+    post = np.asarray(post).flatten()
+    n = len(D)
+    if covariates is None:
+        int_cov = np.ones((n, 1))
+    else:
+        covariates = np.asarray(covariates)
+        if np.all(covariates[:, 0] == 1):
+            int_cov = covariates
+        else:
+            int_cov = np.column_stack((np.ones(n), covariates))
+    
+    # Pesos
+    if i_weights is None:
+        i_weights = np.ones(n)
+    else:
+        i_weights = np.asarray(i_weights)
+        if np.min(i_weights) < 0:
+            raise ValueError("i_weights must be non-negative")
+    
+    # Normalizar pesos
+    i_weights = np.asarray(i_weights).flatten()
+    i_weights = i_weights / np.mean(i_weights)
+
+    pscore_model = sm.GLM(D, int_cov, family=sm.families.Binomial(), freq_weights=i_weights)
+    pscore_results = pscore_model.fit()
+    if not pscore_results.converged:
+        print("Warning: glm algorithm did not converge")
+    if np.any(np.isnan(pscore_results.params)):
+        raise ValueError("Propensity score model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is a likely reason.")
+    ps_fit = pscore_results.predict()
+    ps_fit = np.minimum(ps_fit, 1 - 1e-16)
+
+
+    w_treat_pre = i_weights * D * (1 - post)
+    w_treat_post = i_weights * D * post
+    # print(np.mean(w_treat_pre))
+
+    w_cont_pre = i_weights * ps_fit * (1 - D) * (1 - post)/(1 - ps_fit)
+    w_cont_post = i_weights * ps_fit * (1 - D) * post/(1 - ps_fit)
+
+    # Elements of the influence function (summands)
+    eta_treat_pre = w_treat_pre * y / np.mean(w_treat_pre)
+    eta_treat_post = w_treat_post * y / np.mean(w_treat_post)
+    # print(eta_treat_pre)
+
+    eta_cont_pre = w_cont_pre * y / np.mean(w_cont_pre)
+    eta_cont_post = w_cont_post * y / np.mean(w_cont_post)
+
+    # Estimator of each component
+    att_treat_pre = np.mean(eta_treat_pre)
+    att_treat_post = np.mean(eta_treat_post)
+    att_cont_pre = np.mean(eta_cont_pre)
+    att_cont_post = np.mean(eta_cont_post)
+    ipw_att = (att_treat_post - att_treat_pre) - (att_cont_post - att_cont_pre)
+
+    score_ps = (i_weights * (D - ps_fit))[:, np.newaxis] * int_cov
+    Hessian_ps = pscore_results.cov_params() * n
+    asy_lyn_rep_ps = np.dot(score_ps, Hessian_ps)
+
+    inf_treat_pre = eta_treat_pre - w_treat_pre * att_treat_pre/np.mean(w_treat_pre)
+    inf_treat_post = eta_treat_post - w_treat_post * att_treat_post/np.mean(w_treat_post)
+    inf_treat = inf_treat_post - inf_treat_pre
+    # Now, get the influence function of control component
+    # Leading term of the influence function: no estimation effect
+    inf_cont_pre = eta_cont_pre - w_cont_pre * att_cont_pre/np.mean(w_cont_pre)
+    inf_cont_post = eta_cont_post - w_cont_post * att_cont_post/np.mean(w_cont_post)
+    inf_cont = inf_cont_post - inf_cont_pre
+
+    # Estimation effect from gamma hat (pscore)
+    # Derivative matrix (k x 1 vector)
+  
+    M2_pre = np.mean((w_cont_pre *(y - att_cont_pre))[:, np.newaxis] * int_cov, axis = 0)/np.mean(w_cont_pre)
+    M2_post = np.mean((w_cont_post *(y - att_cont_post))[:, np.newaxis] * int_cov, axis = 0)/np.mean(w_cont_post)
+
+    # Now the influence function related to estimation effect of pscores
+    M2 = M2_post - M2_pre
+    # print()
+
+    inf_cont_ps = np.dot(asy_lyn_rep_ps, M2)
+
+    # Influence function for the control component
+    inf_cont = inf_cont + inf_cont_ps
+
+    #get the influence function of the DR estimator (put all pieces together)
+    att_inf_func = inf_treat - inf_cont
+    # print(np.std(att_inf_func) / np.sqrt(n))
+    se = np.std(att_inf_func, ddof=1) / np.sqrt(n)
+    # print(f"att: {ipw_att} \t se: {se}")    
+    return ipw_att, att_inf_func
+
+
+
+
+

drdid/reg_did.py

@@ -0,0 +1,196 @@
+import numpy as np
+import statsmodels.api as sm
+from numpy import ndarray
+
+from .utils import * 
+import numpy as np
+import statsmodels.api as sm
+from numpy import ndarray
+
+from .utils import * 
+
+def asy_lin_wols(d, post, y, out_y, int_cov, i_w, n):
+  weigths_ols = i_w * d * post
+  # weigths_ols_pre
+  wols_x = weigths_ols[:, n_x] * int_cov
+  wols_ex = (weigths_ols * (y - out_y))[:, n_x] * int_cov
+  cr = np.dot(wols_x.T, int_cov) / n
+  xpx_inv = qr_solver(cr)
+  asy_lin_rep_ols = np.dot(wols_ex, xpx_inv)
+  return asy_lin_rep_ols
+
+import numpy as np
+import statsmodels.api as sm
+
+def reg_did_panel(y1, y0, D, covariates=None, i_weights=None):
+    # Convert inputs to numpy arrays
+    # print("reg: panel")
+    y1 = np.array(y1)
+    y0 = np.array(y0)
+    D = np.array(D)
+    
+    # Sample size
+    n = len(D)
+    
+    # Generate deltaY
+    deltaY = y1 - y0
+    
+    # Add constant to covariate vector
+    if covariates is None:
+        int_cov = np.ones((n, 1))
+    else:
+        covariates = np.asarray(covariates)
+        if np.all(covariates[:, 0] == 1):
+            int_cov = covariates
+        else:
+            int_cov = np.column_stack((np.ones(n), covariates))
+    
+    
+    # Weights
+    if i_weights is None:
+        i_weights = np.ones(n)
+    else:
+        i_weights = np.array(i_weights)
+        if np.min(i_weights) < 0:
+            raise ValueError("i_weights must be non-negative")
+    
+    # Normalize weights
+    i_weights = i_weights / np.mean(i_weights)
+    
+    # Compute the Outcome regression for the control group using OLS
+    model = sm.WLS(deltaY[D == 0], int_cov[D == 0], weights=i_weights[D == 0])
+    results = model.fit()
+    reg_coeff = results.params
+    # print(reg_coeff)
+    if np.any(np.isnan(reg_coeff)):
+        raise ValueError("Outcome regression model coefficients have NA components. Multicollinearity (or lack of variation) of covariates is probably the reason for it.")
+    
+    out_delta = np.dot(int_cov, reg_coeff)
+    # print(out_delta)
+    
+    # Compute the OR-DiD estimator
+    w_treat = i_weights * D
+    w_cont = i_weights * D
+    reg_att_treat = w_treat * deltaY
+    reg_att_cont = w_cont * out_delta
+    eta_treat = np.mean(reg_att_treat) / np.mean(w_treat)
+    eta_cont = np.mean(reg_att_cont) / np.mean(w_cont)
+    # print(np.mean(reg_att_cont), np.mean(w_cont))
+    reg_att = eta_treat - eta_cont
+    
+    # Compute influence function
+    weights_ols = i_weights * (1 - D)
+    wols_x = weights_ols[:, np.newaxis] * int_cov
+    wols_eX = weights_ols[:, np.newaxis] * (deltaY - out_delta)[:, np.newaxis] * int_cov
+    XpX_inv = np.linalg.inv(np.dot(wols_x.T, int_cov) / n)
+    asy_lin_rep_ols = np.dot(wols_eX, XpX_inv)
+    
+    inf_treat = (reg_att_treat - w_treat * eta_treat) / np.mean(w_treat)
+    
+    inf_cont_1 = reg_att_cont - w_cont * eta_cont
+    M1 = np.mean(w_cont[:, np.newaxis] * int_cov, axis=0)
+    inf_cont_2 = np.dot(asy_lin_rep_ols, M1)
+    inf_control = (inf_cont_1 + inf_cont_2) / np.mean(w_cont)
+    
+    reg_att_inf_func = inf_treat - inf_control
+    se = np.std(reg_att_inf_func, ddof=1) / np.sqrt(n)
+    # print(f"att: {reg_att} \t se: {se}")
+    
+    return reg_att, reg_att_inf_func
+
+
+
+
+def reg_did_rc(y, post, D, covariates, i_weights=None):
+#   print("reg_rc")
+  D = np.asarray(D).flatten()
+  post = np.asarray(post).flatten()
+  n = len(D)
+  y = np.asarray(y).flatten()
+  i_weights = np.asarray(i_weights).flatten()
+  int_cov = np.ones((n, 1))
+  
+  if covariates is not None:
+      covariates = np.asarray(covariates)
+      if np.all(covariates[:, 0] == 1):
+          int_cov = covariates
+      else:
+          int_cov = np.column_stack((np.ones(n), covariates))
+  
+  if i_weights is None:
+      i_weights = np.ones(n)
+  elif np.min(i_weights) < 0:
+      raise ValueError("i_weights must be non-negative")
+  
+  i_weights = i_weights / np.mean(i_weights)
+  
+  # Pre-treatment regression
+  mask_pre = (D == 0) & (post == 0)
+  X_pre = int_cov[mask_pre]
+  y_pre = y[mask_pre]
+  w_pre = i_weights[mask_pre]
+  model_pre = sm.WLS(y_pre, X_pre, weights=w_pre)
+  results_pre = model_pre.fit()
+  reg_coeff_pre = results_pre.params
+  
+  if np.any(np.isnan(reg_coeff_pre)):
+      raise ValueError("Outcome regression model coefficients have NA components. \n Multicollinearity of covariates is probably the reason for it.")
+  
+  out_y_pre = np.dot(int_cov, reg_coeff_pre)
+  
+  # Post-treatment regression
+  mask_post = (D == 0) & (post == 1)
+  X_post = int_cov[mask_post]
+  y_post = y[mask_post]
+  w_post = i_weights[mask_post]
+  model_post = sm.WLS(y_post, X_post, weights=w_post)
+  results_post = model_post.fit()
+  reg_coeff_post = results_post.params
+  
+  if np.any(np.isnan(reg_coeff_post)):
+      raise ValueError("Outcome regression model coefficients have NA components. \n Multicollinearity (or lack of variation) of covariates is probably the reason for it.")
+  
+  out_y_post = np.dot(int_cov, reg_coeff_post)
+  
+  w_treat_pre = i_weights * D * (1 - post)
+  w_treat_post = i_weights * D * post
+  w_cont = i_weights * D
+  reg_att_treat_pre = w_treat_pre * y
+  reg_att_treat_post = w_treat_post * y
+  reg_att_cont = w_cont * (out_y_post - out_y_pre)
+  eta_treat_pre = np.mean(reg_att_treat_pre) / np.mean(w_treat_pre)
+  eta_treat_post = np.mean(reg_att_treat_post) / np.mean(w_treat_post)
+  eta_cont = np.mean(reg_att_cont) / np.mean(w_cont)
+  reg_att = (eta_treat_post - eta_treat_pre) - eta_cont
+  
+  weights_ols_pre = i_weights * (1 - D) * (1 - post)
+  # print(weights_ols_pre.reshape((n, 1)))
+  wols_x_pre = weights_ols_pre[:, np.newaxis] * int_cov
+  wols_eX_pre = weights_ols_pre[:, np.newaxis] * (y - out_y_pre)[:, np.newaxis] * int_cov
+  XpX_inv_pre = np.linalg.inv(np.dot(wols_x_pre.T, int_cov) / n)
+  asy_lin_rep_ols_pre = np.dot(wols_eX_pre, XpX_inv_pre)
+  
+  weights_ols_post = i_weights * (1 - D) * post
+  wols_x_post = weights_ols_post[:, np.newaxis] * int_cov
+  wols_eX_post = weights_ols_post[:, np.newaxis] * (y - out_y_post)[:, np.newaxis] * int_cov
+  XpX_inv_post = np.linalg.inv(np.dot(wols_x_post.T, int_cov) / n)
+  asy_lin_rep_ols_post = np.dot(wols_eX_post, XpX_inv_post)
+  
+  inf_treat_pre = (reg_att_treat_pre - w_treat_pre * eta_treat_pre) / np.mean(w_treat_pre)
+  inf_treat_post = (reg_att_treat_post - w_treat_post * eta_treat_post) / np.mean(w_treat_post)
+  inf_treat = inf_treat_post - inf_treat_pre
+  
+  inf_cont_1 = (reg_att_cont - w_cont * eta_cont)
+  M1 = np.mean(w_cont[:, np.newaxis] * int_cov, axis=0)
+  inf_cont_2_post = np.dot(asy_lin_rep_ols_post, M1)
+  inf_cont_2_pre = np.dot(asy_lin_rep_ols_pre, M1)
+  inf_control = (inf_cont_1 + inf_cont_2_post - inf_cont_2_pre) / np.mean(w_cont)
+  
+  reg_att_inf_func = (inf_treat - inf_control)
+#   se_reg_att = np.std(reg_att_inf_func) / np.sqrt(n)
+  se = np.std(reg_att_inf_func, ddof=1) / np.sqrt(n)
+#   print(f"att: {reg_att} \t se: {se}")
+
+  return reg_att, reg_att_inf_func
+
+

drdid/utils.py

@@ -0,0 +1,94 @@
+import numpy as np
+import statsmodels.api as sm
+
+lm = sm.WLS
+glm = sm.GLM
+n_x = np.newaxis
+qr_solver = np.linalg.pinv
+binomial = sm.families.Binomial()
+mean = np.mean
+
+def has_intercept(covariates, n):
+  int_cov = np.ones(n)
+  if covariates is not None:
+    if np.all(covariates[:, 0] == int_cov):
+      int_cov = covariates
+    else:
+      int_cov = np.concatenate((np.ones((n, 1)), covariates), axis=1)
+  
+  return int_cov
+
+def has_weights(weights, n):
+  if weights is None:
+    weights = np.ones(n)
+  elif np.min(weights) < 0:
+    raise ValueError('weights must be non-negative')
+
+def asy_lin_wols(w, d, x, y, out_y, pst = 1):
+  n = len(y)
+  w_ols = w * d * pst
+  wols_x = w_ols[:, n_x] * x
+  w_diff = w_ols * (y - out_y)
+  wols_ex = w_diff[:, n_x] * x
+  cr = np.dot(wols_x.T, x) / n
+  xpx_inv = qr_solver(cr)
+  asy_lin = np.dot(wols_ex, xpx_inv)
+  return asy_lin
+
+def out_wols(y, d, x, rows, wgts, pst=1):
+  ols_coef = lm(
+    y[rows], x[rows], weights=wgts[rows]
+  ).fit().params
+  out_y = np.dor(ols_coef, x.T)
+
+  ### asy_lin_rep
+  asy_lin_rep = asy_lin_wols(
+    wgts, d, x, y, out_y, pst
+  )
+
+
+  return out_y, asy_lin_rep
+
+def w_tc_val(w, d, pst=1):
+  return w * d * pst
+
+def eta_val(att, w_tc=1, y=None):
+  if y is None:
+    eta_r = mean(att) / mean(w_tc)
+  else:
+    eta_r = att * y / mean(att)
+
+
+def inf_treat_f(att, w, eta):
+  inf_f_u = att - w * eta
+  inf_f = inf_f_u / mean(w)
+  return inf_f
+
+def bstrap_se():
+  # replace with mboot
+  pass
+
+def fit_ps(d, x, w, post = 1):
+  n = len(d)
+  glm_fit = glm(
+    d, x, family=binomial, freq_weights=w
+  ).fit()
+  ps_fit = glm_fit.fittedvalues
+  ps_fit = np.minimum(ps_fit, 1 - 1e-16)
+
+  rest_cont = w * ps_fit * (1 - d)
+  post1 = (1 - post)
+  ps_fit1 = (1 - ps_fit)
+  # Rc
+  w_cont_pre = rest_cont * post1 / ps_fit1 
+  w_cont_post = rest_cont * post / ps_fit
+  # panel
+  w_cont = rest_cont / ps_fit1
+
+  w_ps = w * (d - ps_fit)
+  score_ps = w_ps[:, n_x] * x
+  hessian = glm_fit.cov_params() * n
+
+  asy_lin_ps = np.dot(score_ps, hessian)
+
+  return (ps_fit, w_cont_pre, w_cont, w_cont_post, 0, asy_lin_ps)

drdid-1.1.6.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: drdid
+Version: 1.1.6
+Summary: Double Robust Difference in Difference y python
+Home-page: https://github.com/d2cml-ai/drdid
+Author: Jhon Flores
+Author-email: fr.jhonk@gmail.com
+License: MIT
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: statsmodels
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+
+    Implementation of drdid for Python, R-like syntax with return destructuring using optimized Python code.
+
+    See the original [R package](https://github.com/pedrohcgs/DRDID/tree/master)
+    

drdid-1.1.6.dist-info/RECORD

@@ -0,0 +1,11 @@
+drdid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+drdid/_version_.py,sha256=dh8J4El9b4iqphBgXLgnpBBahiEA-LUwKZYLjWS-x3c,17
+drdid/drdid.py,sha256=Ii5qQ0lInYHLSsGXEEpobhlMq1BFUK3LiZP73lHBifw,13156
+drdid/ipwd_did.py,sha256=vrnEyCg9jsZabsjcp_S8KzPuRt-eaXOlF_72TFavZcE,6273
+drdid/reg_did.py,sha256=IX5x7MLXsL7qhCtcBL3bVDPuPemN5QEVW50soEQ3G5k,7039
+drdid/utils.py,sha256=DLz3zfaJBtkQH72t_Ks5dUeZCqUf5HAz--iDkPIh5OY,2154
+drdid-1.1.6.dist-info/licenses/LICENSE,sha256=074-9zp7UvJPkvubrgLWw_JB4EgZiYCjAtzpgi9es_I,1142
+drdid-1.1.6.dist-info/METADATA,sha256=nT8P01tCuh9uwMNrDABO1pVTcCt3VaAnO6etBj8GlfY,690
+drdid-1.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+drdid-1.1.6.dist-info/top_level.txt,sha256=xRabzMBAiGz5Aks1Wcebo_WtauCRbYgkHYo3DQ-G1eM,6
+drdid-1.1.6.dist-info/RECORD,,

drdid-1.1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

drdid-1.1.6.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Pedro Sant’Anna, Carlos Guevara, Jhon Flores, Alexander Quispe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

drdid-1.1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+drdid