csdid 0.2.7__py3-none-any.whl

csdid/aggte_fnc/utils.py

@@ -0,0 +1,196 @@
+from csdid.utils.bmisc import TorF
+from csdid.utils.mboot import mboot
+
+import numpy as np
+import scipy.stats as stats
+import pandas as pd
+
+def wif(keepers, pg, weights_ind, G, group):
+    # note: weights are all of the form P(G=g|cond)/sum_cond(P(G=g|cond))
+    # this is equal to P(G=g)/sum_cond(P(G=g)) which simplifies things here
+    pg = np.array(pg)
+    group = np.array(group)
+    
+    # effect of estimating weights in the numerator
+    if1 = np.empty((len(weights_ind), len(keepers)))
+    for i, k  in enumerate(keepers):
+        numerator = (weights_ind * 1 * TorF(G == group[k])) - pg[k]
+        # denominator = sum(np.array(pg)[keepers]) )[:, None]  
+        denominator = np.sum(pg[keepers])
+
+        result = numerator[:, None]  / denominator
+        if1[:, i] = result.squeeze()
+    
+    # effect of estimating weights in the denominator
+    if2 = np.empty((len(weights_ind), len(keepers)))
+    for i, k  in enumerate(keepers):
+        numerator = ( weights_ind * 1 * TorF(G == group[k]) ) - pg[k]
+        # result = numerator.to_numpy()[:, None]  @ multipler[:, None].T
+        if2[:, i] = numerator.squeeze()
+    if2 = np.sum(if2, axis=1)    
+    multiplier = ( pg[keepers] / sum( pg[keepers] ) ** 2 )   
+    if2 = np.outer( if2 , multiplier)
+
+    # if1 = [((weights_ind * 1*TorF(G==group[k])) - pg[k]) / sum(pg[keepers]) for k in keepers]
+    # if2 = np.dot(np.array([weights_ind*1*TorF(G==group[k]) - pg[k] for k in keepers]).T, pg[keepers]/(sum(pg[keepers])**2))
+    wif_factor = if1 - if2
+    return wif_factor
+
+def get_agg_inf_func(att, inffunc, whichones, weights_agg, wif=None):
+    # enforce weights are in matrix form
+    weights_agg = np.asarray(weights_agg)
+
+    # multiplies influence function times weights and sums to get vector of weighted IF (of length n)
+    thisinffunc = np.dot(inffunc[:, whichones], weights_agg)
+
+    # Incorporate influence function of the weights
+    if wif is not None:
+        thisinffunc = thisinffunc + np.dot(wif, np.array(att[whichones]))
+        
+    # return influence function
+    return thisinffunc
+
+
+def get_se(thisinffunc, DIDparams=None):
+    alpha = 0.05
+    bstrap = False
+    if DIDparams is not None:
+        bstrap = DIDparams['bstrap']
+        alpha = DIDparams['alp']
+        cband = DIDparams['cband']
+        n = len(thisinffunc)
+
+    if bstrap:
+        bout = mboot(thisinffunc, DIDparams)
+        return bout['se']
+    else:
+        return np.sqrt(np.mean((thisinffunc)**2) / n)
+
+def AGGTEobj(overall_att=None,
+             overall_se=None,
+             typec="simple",
+             egt=None,
+             att_egt=None,
+             se_egt=None,
+             crit_val_egt=None,
+             inf_function=None,
+             min_e=None,
+             max_e=None,
+             balance_e=None,
+             call=None,
+             DIDparams=None):
+
+    out = {
+        "overall_att": overall_att,
+        "overall_se": overall_se,
+        "type": typec,
+        "egt": egt,
+        "att_egt": att_egt,
+        "se_egt": se_egt,
+        "crit_val_egt": crit_val_egt,
+        "inf_function": inf_function,
+        "min_e": min_e,
+        "max_e": max_e,
+        "balance_e": balance_e,
+        "call": call,
+        "DIDparams": DIDparams
+    }
+    
+    
+    # Overall estimates
+    alp = out["DIDparams"]["alp"]
+    pointwise_cval = stats.norm.ppf(1 - alp / 2)
+    overall_cband_upper = out["overall_att"] + pointwise_cval * out["overall_se"]
+    overall_cband_lower = out["overall_att"] - pointwise_cval * out["overall_se"]
+    out1 = np.column_stack((out["overall_att"], out["overall_se"], overall_cband_lower, overall_cband_upper))
+    out1 = np.round(out1, 4)
+    overall_sig = (overall_cband_upper < 0) | (overall_cband_lower > 0)
+    overall_sig[np.isnan(overall_sig)] = False
+    overall_sig_text = np.where(overall_sig, "*", "")
+    out1 = np.column_stack((out1, overall_sig_text))
+    
+    print("\n")
+    if out["type"] == "dynamic":
+        print("Overall summary of ATT's based on event-study/dynamic aggregation:")
+    elif out["type"] == "group":
+        print("Overall summary of ATT's based on group/cohort aggregation:")
+    elif out["type"] == "calendar":
+        print("Overall summary of ATT's based on calendar time aggregation:")
+    colnames = ["ATT", "Std. Error", f"[{100 * (1 - out['DIDparams']['alp'])}%"," Conf. Int.]", ""]
+    print(pd.DataFrame(out1, columns=colnames).to_string(index=False))
+    print("\n")
+    
+    # Handle cases depending on type
+    if out["type"] in ["group", "dynamic", "calendar"]:
+        if out["type"] == "dynamic":
+            c1name = "Event time"
+            print("Dynamic Effects:")
+        elif out["type"] == "group":
+            c1name = "Group"
+            print("Group Effects:")
+        elif out["type"] == "calendar":
+            c1name = "Time"
+            print("Time Effects (calendar):")
+    
+        cband_text1a = f"{100 * (1 - out['DIDparams']['alp'])}% "
+        cband_text1b = "Simult. " if out["DIDparams"]["bstrap"] else "Pointwise "
+        cband_text1 = f"[{cband_text1a}{cband_text1b}"
+    
+        cband_lower = out["att_egt"] - out["crit_val_egt"] * out["se_egt"]
+        cband_upper = out["att_egt"] + out["crit_val_egt"] * out["se_egt"]
+    
+        sig = (cband_upper < 0) | (cband_lower > 0)
+        sig[np.isnan(sig)] = False
+        sig_text = np.where(sig, "*", "").T
+
+        out2 = pd.DataFrame([out["egt"], 
+                             out["att_egt"], 
+                             out["se_egt"].flatten(), 
+                             np.hstack(cband_lower),
+                             np.hstack(cband_upper)]).T
+        
+        out2 = out2.round(4)
+        out2[0] = out2[0].astype(int)
+        out2 = pd.concat([out2, pd.DataFrame(sig_text, columns=['sig_text']) ], axis=1)    
+        
+        out2.columns = [c1name, "Estimate", "Std. Error", cband_text1, "Conf. Band", ""]
+        print(out2)
+    
+    
+    
+
+    
+    print("---")
+    print("Signif. codes: `*' confidence band does not cover 0")
+    
+    # Set control group text
+    control_group = out["DIDparams"]["control_group"]
+    control_group_text = None
+    if control_group == "nevertreated":
+        control_group_text = "Never Treated"
+    elif control_group == "notyettreated":
+        control_group_text = "Not Yet Treated"
+    
+    if control_group:
+        print("Control Group: ", control_group_text, ", ")
+    
+    # Anticipation periods
+    print("Anticipation Periods: ", out["DIDparams"]["anticipation"])
+    
+    # Estimation method text
+    est_method = out["DIDparams"]["est_method"]
+    if isinstance(est_method, str):
+        est_method_text = est_method
+        if est_method == "dr":
+            est_method_text = "Doubly Robust"
+        elif est_method == "ipw":
+            est_method_text = "Inverse Probability Weighting"
+        elif est_method == "reg":
+            est_method_text = "Outcome Regression"
+    
+        print("Estimation Method: ", est_method_text)
+        print("\n")
+        
+    return out
+
+

csdid/att_gt.py

@@ -0,0 +1,245 @@
+# from aggte import AGGte
+from csdid.aggte_fnc.aggte import aggte as agg_te
+
+from csdid.attgt_fnc.preprocess_did import pre_process_did
+from csdid.attgt_fnc.compute_att_gt import compute_att_gt
+
+from csdid.utils.mboot import mboot
+
+from csdid.plots.gplot import gplot, splot
+
+
+import matplotlib.pyplot as plt
+
+import warnings
+
+import numpy as np, pandas as pd
+
+# class ATTgt(AGGte):
+class ATTgt:
+  def __init__(self, yname, tname, idname, gname, data, control_group = ['nevertreated', 'notyettreated'], 
+  xformla: str = None, panel = True, allow_unbalanced_panel = True, 
+  clustervar = None, weights_name = None, anticipation = 0, 
+  cband = False, biters = 1000, alp = 0.05
+  ):
+    dp = pre_process_did(
+      yname=yname, tname = tname, idname=idname, gname = gname,
+      data = data, control_group=control_group, anticipation=anticipation,
+      xformla=xformla, panel=panel, allow_unbalanced_panel=allow_unbalanced_panel, cband=cband, clustervar=None, weights_name=None
+    )
+
+    dp['biters'] = biters
+    dp['alp'] = alp
+    dp['true_repeated_cross_sections'] = dp['true_rep_cross_section']
+    dp['cband'] = cband
+    dp['panel'] = panel
+    self.dp = dp
+
+  def fit(self, est_method = 'dr', base_period = 'varying', bstrap = True):
+    # print(self.dp)
+    dp = self.dp
+    result, inffunc = compute_att_gt(dp, est_method = est_method, base_period = base_period)
+    att = result['att']
+    n_len = list(map(len, inffunc))
+    crit_val, se, V = (
+            1.96,
+            np.std(inffunc, axis=1, ddof = 1) / np.sqrt(n_len),
+            np.zeros(len(att)),
+        )
+    if bstrap:
+      ref_se = mboot(inffunc.T, dp)
+      crit_val, se = ref_se['crit_val'], ref_se['se']
+      V = ref_se['V']
+    
+    ############# aggte input
+    group = result['group']
+    att = result['att']
+    tt = result['year']
+    inf_fnc = {'inffunc': inffunc.T}
+
+    dp['bstrap'] = bstrap
+    dp['est_method'] = est_method
+    dp['base_period'] = base_period
+    self.dp = dp
+    n = dp['n']
+
+    mp = {
+      'group': group, 'att': att, 't': tt,
+      'DIDparams': dp, 'inffunc': inf_fnc, 
+      'n': n
+    }
+    self.MP = mp
+
+
+    cband_lower = att - crit_val * se
+    cband_upper = att + crit_val * se
+    sig = (cband_upper < 0) | (cband_lower > 0)
+    sig[np.isnan(sig)] = False
+    sig_text = np.where(sig, "*", "")
+
+    result.update(
+      {
+        'se': se, 'l_se': cband_lower,
+        'c': crit_val,
+        'u_se': cband_upper, 'sig': sig_text
+       })
+    
+    self.results = result
+
+    rst = result
+    did_object = {
+      'group': mp['group'],
+      't': mp['t'],
+      'att': rst['att'],
+      'se': rst['se'],
+      'c': rst['c'],
+    }
+    self.did_object = did_object
+    return self
+  def summ_attgt(self, n = 4):
+    result = self.results
+    att_gt = pd.DataFrame(result)
+    att_gt = att_gt.drop('c', axis=1)
+    name_attgt_df = ['Group', 'Time', 'ATT(g, t)', 'Post', "Std. Error", "[95% Pointwise", 'Conf. Band]', '']
+    att_gt.columns = name_attgt_df
+    att_gt = att_gt.round(n)
+    self.summary2 = att_gt
+    return self
+
+  def aggte(
+    self, 
+    typec         = "group",
+    balance_e     = None,
+    min_e         = float('-inf'),
+    max_e         = float('inf'),
+    na_rm         = False,
+    bstrap        = None,
+    biters        = None,
+    cband         = None,
+    alp           = None,
+    clustervars   = None,
+    ):
+    mp = self.MP
+    did_object = self.did_object
+    
+    did_object.update({
+      'type': typec
+      }
+    )
+
+
+    atte = agg_te(
+      mp, typec=typec, balance_e=balance_e, 
+      min_e=min_e, max_e=max_e, na_rm=na_rm, bstrap=bstrap, 
+      biters=biters, cband=cband, alp=alp, clustervars=clustervars
+    )
+
+    self.atte = atte
+    return self
+  def plot_attgt(self, ylim=None, 
+                xlab=None, 
+                ylab=None, 
+                title="Group",
+                xgap=1, 
+                ncol=1, 
+                legend=True, 
+                group=None, 
+                ref_line=0,
+                theming=True, 
+                grtitle="Group"
+                ):
+
+    did_object = self.did_object
+
+    grp = did_object['group']
+    t_i = did_object['t']
+
+    G = len(np.unique(grp))
+    Y = len(np.unique(t_i))
+    g = np.unique(grp)[np.argsort(np.unique(grp))].astype(int)
+    y = np.unique(t_i)
+
+    results = pd.DataFrame({'year': np.tile(y, G)})
+    results['group'] = np.repeat(g, Y)
+    results['grtitle'] = grtitle + ' ' + results['group'].astype(str)
+    results['att'] = did_object['att']
+    results['att_se'] = did_object['se']
+    results['post'] = np.where(results['year'] >= grp, 1, 0)
+    results['year'] = results['year']
+    results['c'] = did_object['c']
+
+    self.results_plot_df_attgt = results
+
+    if group is None:
+      group = g
+      if any(group not in g for group in group):
+        raise ValueError("Some of the specified groups do not exist in the data. Reporting all available groups.")
+
+
+    legend_1 = False    # for multiple subplots, legend outside 
+    fig, axes = plt.subplots(nrows=len(group), ncols=1, figsize=(10, 5))  # Adjust the figsize as needed
+    handles = []
+    labels = []
+    for i, group_cat in enumerate(group):
+        group_data = results.loc[results['group'] == group_cat]
+        title = group_data['grtitle'].unique()[0]
+        ax = axes[i]
+        ax = gplot(group_data, ax, ylim, xlab, ylab, title, xgap, legend_1, ref_line, theming)
+    plt.tight_layout()
+    if legend is True:
+        handles_ax, labels_ax = ax.get_legend_handles_labels()
+        handles.extend(handles_ax)
+        labels.extend(labels_ax)
+        fig.legend(handles, labels, loc='lower center', fontsize='small', bbox_to_anchor=(0.545, -0.075), ncol=2)
+    
+    plt.show()
+    return fig 
+
+  def plot_aggte(self, ylim=None, 
+                   xlab=None, 
+                   ylab=None, 
+                   title="", 
+                   xgap=1, 
+                   legend=True, 
+                   ref_line=0, 
+                   theming=True,
+                   **kwargs):
+
+    did_object = self.atte
+
+    post_treat = 1 * (np.asarray(did_object["egt"]).astype(int) >= 0)
+    
+    results = {
+        "year": list(map(int, did_object["egt"])),
+        "att": did_object["att_egt"],
+        "att_se": did_object["se_egt"][0],
+        "post": post_treat
+    }
+    
+    results = pd.DataFrame(results)
+    self.results_plot_df_aggte = results
+    
+    if did_object['crit_val_egt'] is None:
+        results['c'] = abs(norm.ppf(0.025))
+    else:
+        results['c'] = did_object['crit_val_egt']
+
+    if title == "":
+        title = "Average Effect by Group" if\
+          did_object["type"] == "group" else\
+            "Average Effect by Length of Exposure"
+
+
+    if did_object["type"] == "group":
+        fig, ax = plt.subplots(figsize=(10, 5))
+        p = splot(results, ax, ylim, xlab, ylab, title, legend, ref_line, theming)
+        plt.tight_layout()
+        plt.show()
+
+    else:
+        fig, ax = plt.subplots(figsize=(10, 5))
+        p = gplot(results, ax, ylim, xlab, ylab, title, xgap, legend, ref_line, theming)
+        plt.tight_layout()
+        plt.show() 
+        
+    return p