From d60eed85edfff391c9f14d9c6205e7363d013d03 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 19 Dec 2023 11:06:23 -0500 Subject: [PATCH 1/9] add qini curve plotting Signed-off-by: amarv --- econml/validate/drtester.py | 10 +++++--- econml/validate/results.py | 47 ++++++++++++++++++++++++++++++++++++- econml/validate/utils.py | 11 +++++++-- 3 files changed, 62 insertions(+), 6 deletions(-) diff --git a/econml/validate/drtester.py b/econml/validate/drtester.py index 1948bed80..6f5e82017 100644 --- a/econml/validate/drtester.py +++ b/econml/validate/drtester.py @@ -519,7 +519,7 @@ def evaluate_qini( self.get_cate_preds(Xval, Xtrain) if self.n_treat == 1: - qini, qini_err = calc_qini_coeff( + qini, qini_err, qini_curve_df = calc_qini_coeff( self.cate_preds_train_, self.cate_preds_val_, self.dr_val_, @@ -527,11 +527,13 @@ def evaluate_qini( ) qinis = [qini] errs = [qini_err] + curve_dfs = [qini_curve_df] else: qinis = [] errs = [] + curve_dfs = [] for k in range(self.n_treat): - qini, qini_err = calc_qini_coeff( + qini, qini_err, qini_curve_df = calc_qini_coeff( self.cate_preds_train_[:, k], self.cate_preds_val_[:, k], self.dr_val_[:, k], @@ -540,6 +542,7 @@ def evaluate_qini( qinis.append(qini) errs.append(qini_err) + curve_dfs.append(qini_curve_df) pvals = [st.norm.sf(abs(q / e)) for q, e in zip(qinis, errs)] @@ -547,7 +550,8 @@ def evaluate_qini( params=qinis, errs=errs, pvals=pvals, - treatments=self.treatments + treatments=self.treatments, + curve_dfs=curve_dfs ) return self.qini_res diff --git a/econml/validate/results.py b/econml/validate/results.py index 0b3edaeaa..6466a03bb 100644 --- a/econml/validate/results.py +++ b/econml/validate/results.py @@ -155,12 +155,14 @@ def __init__( params: List[float], errs: List[float], pvals: List[float], - treatments: np.array + treatments: np.array, + curve_dfs: List[pd.DataFrame] ): self.params = params self.errs = errs self.pvals = pvals self.treatments = treatments + self.curves = curve_dfs def summary(self): """ @@ -182,6 +184,34 @@ def summary(self): }).round(3) return res + def plot_qini(self, tmt: int): + """ + Plots QINI curves. + + Parameters + ---------- + tmt: integer + Treatment level to plot + + Returns + ------- + matplotlib plot with percentage treated on x-axis and QINI (and 95% CI) on y-axis + """ + if tmt == 0: + raise Exception('Plotting only supported for treated units (not controls)') + + tmt_idx = [i for i, x in enumerate(self.treatments[1:]) if x == i][0] + df = self.curves[tmt_idx] + fig = df.plot( + kind='scatter', + x='Percentage treated', + y='Est. QINI', + yerr='95_err', + ylabel='Gain in Policy Value over Random Treatment', + ) + + return fig + class EvaluationResults: """ @@ -243,3 +273,18 @@ def plot_cal(self, tmt: int): matplotlib plot with predicted GATE on x-axis and GATE (and 95% CI) on y-axis """ return self.cal.plot_cal(tmt) + + def plot_qini(self, tmt: int): + """ + Plots QINI curves. + + Parameters + ---------- + tmt: integer + Treatment level to plot + + Returns + ------- + matplotlib plot with percentage treated on x-axis and QINI value (and 95% CI) on y-axis + """ + return self.qini.plot_qini(tmt) diff --git a/econml/validate/utils.py b/econml/validate/utils.py index 1ed45225f..391f1a173 100644 --- a/econml/validate/utils.py +++ b/econml/validate/utils.py @@ -1,6 +1,7 @@ from typing import Tuple import numpy as np +import pandas as pd def calculate_dr_outcomes( @@ -52,7 +53,7 @@ def calc_qini_coeff( cate_preds_val: np.array, dr_val: np.array, percentiles: np.array -) -> Tuple[float, float]: +) -> Tuple[float, float, pd.DataFrame]: """ Helper function for QINI coefficient calculation. See documentation for "evaluate_qini" method for more details. @@ -91,4 +92,10 @@ def calc_qini_coeff( qini = np.sum(toc[:-1] * np.diff(percentiles) / 100) qini_stderr = np.sqrt(np.mean(qini_psi ** 2) / n) - return qini, qini_stderr + curve_df = pd.DataFrame({ + 'Percentage treated': 100 - percentiles, + 'Est. QINI': toc, + '95_err': 1.96 * toc_std + }) + + return qini, qini_stderr, curve_df From 7b8415b7fe6f156f18beeacc4f5e4ffba54e9946 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 19 Dec 2023 11:31:16 -0500 Subject: [PATCH 2/9] add toc curve Signed-off-by: amarv --- econml/validate/drtester.py | 60 +++++++++++++++++++++---------------- econml/validate/results.py | 49 ++++++++++++++++++++---------- econml/validate/utils.py | 36 +++++++++++++--------- 3 files changed, 91 insertions(+), 54 deletions(-) diff --git a/econml/validate/drtester.py b/econml/validate/drtester.py index 6f5e82017..13153bd03 100644 --- a/econml/validate/drtester.py +++ b/econml/validate/drtester.py @@ -8,8 +8,8 @@ from statsmodels.api import OLS from statsmodels.tools import add_constant -from .results import CalibrationEvaluationResults, BLPEvaluationResults, QiniEvaluationResults, EvaluationResults -from .utils import calculate_dr_outcomes, calc_qini_coeff +from .results import CalibrationEvaluationResults, BLPEvaluationResults, UpliftEvaluationResults, EvaluationResults +from .utils import calculate_dr_outcomes, calc_uplift class DRtester: @@ -480,12 +480,13 @@ def evaluate_blp( return self.blp_res - def evaluate_qini( + def evaluate_uplift( self, Xval: np.array = None, Xtrain: np.array = None, - percentiles: np.array = np.linspace(5, 95, 50) - ) -> QiniEvaluationResults: + percentiles: np.array = np.linspace(5, 95, 50), + metric: str = 'qini' + ) -> UpliftEvaluationResults: """ Calculates QINI coefficient for the given model as in Radcliffe (2007), where units are ordered by predicted CATE values and a running measure of the average treatment effect in each cohort is kept as we progress @@ -505,56 +506,63 @@ def evaluate_qini( percentiles: one-dimensional array, default ``np.linspace(5, 95, 50)'' Array of percentiles over which the QINI curve should be constructed. Defaults to 5%-95% in intervals of 5%. + metric: string, default 'qini' + Which type of uplift curve to evaluate. Must be one of ['toc', 'qini'] Returns ------- - QiniEvaluationResults object showing the results of the QINI fit + UpliftEvaluationResults object showing the fitted results """ if not hasattr(self, 'dr_val_'): raise Exception("Must fit nuisances before evaluating") + if not (metric in ['qini', 'toc']): + raise ValueError("Uplift metric must be one of ['qini', 'toc']") + if (not hasattr(self, 'cate_preds_train_')) or (not hasattr(self, 'cate_preds_val_')): if (Xval is None) or (Xtrain is None): raise Exception('CATE predictions not yet calculated - must provide both Xval, Xtrain') self.get_cate_preds(Xval, Xtrain) if self.n_treat == 1: - qini, qini_err, qini_curve_df = calc_qini_coeff( + coeff, err, curve_df = calc_uplift( self.cate_preds_train_, self.cate_preds_val_, self.dr_val_, - percentiles + percentiles, + metric ) - qinis = [qini] - errs = [qini_err] - curve_dfs = [qini_curve_df] + coeffs = [coeff] + errs = [err] + curve_dfs = [curve_df] else: - qinis = [] + coeffs = [] errs = [] curve_dfs = [] for k in range(self.n_treat): - qini, qini_err, qini_curve_df = calc_qini_coeff( + coeff, err, curve_df = calc_uplift( self.cate_preds_train_[:, k], self.cate_preds_val_[:, k], self.dr_val_[:, k], - percentiles + percentiles, + metric ) - qinis.append(qini) - errs.append(qini_err) - curve_dfs.append(qini_curve_df) + coeffs.append(coeff) + errs.append(err) + curve_dfs.append(curve_df) - pvals = [st.norm.sf(abs(q / e)) for q, e in zip(qinis, errs)] + pvals = [st.norm.sf(abs(q / e)) for q, e in zip(coeffs, errs)] - self.qini_res = QiniEvaluationResults( - params=qinis, + self.uplift_res = UpliftEvaluationResults( + params=coeffs, errs=errs, pvals=pvals, treatments=self.treatments, curve_dfs=curve_dfs ) - return self.qini_res + return self.uplift_res def evaluate_all( self, @@ -563,8 +571,8 @@ def evaluate_all( n_groups: int = 4 ) -> EvaluationResults: """ - Implements the best linear prediction (`evaluate_blp'), calibration (`evaluate_cal') and QINI coefficient - (`evaluate_qini') methods. + Implements the best linear prediction (`evaluate_blp'), calibration (`evaluate_cal'), uplift curve + ('evaluate_uplift') methods Parameters ---------- @@ -587,12 +595,14 @@ def evaluate_all( blp_res = self.evaluate_blp() cal_res = self.evaluate_cal(n_groups=n_groups) - qini_res = self.evaluate_qini() + qini_res = self.evaluate_uplift(metric='qini') + toc_res = self.evaluate_uplift(metric='toc') self.res = EvaluationResults( blp_res=blp_res, cal_res=cal_res, - qini_res=qini_res + qini_res=qini_res, + toc_res=toc_res ) return self.res diff --git a/econml/validate/results.py b/econml/validate/results.py index 6466a03bb..e53b294a0 100644 --- a/econml/validate/results.py +++ b/econml/validate/results.py @@ -132,9 +132,9 @@ def summary(self): return res -class QiniEvaluationResults: +class UpliftEvaluationResults: """ - Results class for QINI test. + Results class for uplift curve-based tests. Parameters ---------- @@ -178,36 +178,35 @@ def summary(self): """ res = pd.DataFrame({ 'treatment': self.treatments[1:], - 'qini_est': self.params, - 'qini_se': self.errs, - 'qini_pval': self.pvals + 'est': self.params, + 'se': self.errs, + 'pval': self.pvals }).round(3) return res - def plot_qini(self, tmt: int): + def plot_uplift(self, tmt: int): """ - Plots QINI curves. + Plots uplift curves. Parameters ---------- tmt: integer - Treatment level to plot + Treatment level (index) to plot Returns ------- - matplotlib plot with percentage treated on x-axis and QINI (and 95% CI) on y-axis + matplotlib plot with percentage treated on x-axis and uplift metric (and 95% CI) on y-axis """ if tmt == 0: raise Exception('Plotting only supported for treated units (not controls)') - tmt_idx = [i for i, x in enumerate(self.treatments[1:]) if x == i][0] - df = self.curves[tmt_idx] + df = self.curves[tmt - 1] fig = df.plot( kind='scatter', x='Percentage treated', - y='Est. QINI', + y='value', yerr='95_err', - ylabel='Gain in Policy Value over Random Treatment', + ylabel='Gain over Random', ) return fig @@ -232,11 +231,13 @@ def __init__( self, cal_res: CalibrationEvaluationResults, blp_res: BLPEvaluationResults, - qini_res: QiniEvaluationResults + qini_res: UpliftEvaluationResults, + toc_res: UpliftEvaluationResults ): self.cal = cal_res self.blp = blp_res self.qini = qini_res + self.toc = toc_res def summary(self): """ @@ -253,6 +254,9 @@ def summary(self): res = self.blp.summary().merge( self.qini.summary(), on='treatment' + ).merge( + self.toc.summary(), + on='treatment' ).merge( self.cal.summary(), on='treatment' @@ -287,4 +291,19 @@ def plot_qini(self, tmt: int): ------- matplotlib plot with percentage treated on x-axis and QINI value (and 95% CI) on y-axis """ - return self.qini.plot_qini(tmt) + return self.qini.plot_uplift(tmt) + + def plot_toc(self, tmt: int): + """ + Plots TOC curves. + + Parameters + ---------- + tmt: integer + Treatment level to plot + + Returns + ------- + matplotlib plot with percentage treated on x-axis and TOC value (and 95% CI) on y-axis + """ + return self.toc.plot_uplift(tmt) diff --git a/econml/validate/utils.py b/econml/validate/utils.py index 391f1a173..aa0c22ed9 100644 --- a/econml/validate/utils.py +++ b/econml/validate/utils.py @@ -48,15 +48,16 @@ def calculate_dr_outcomes( return dr -def calc_qini_coeff( +def calc_uplift( cate_preds_train: np.array, cate_preds_val: np.array, dr_val: np.array, - percentiles: np.array + percentiles: np.array, + metric: str ) -> Tuple[float, float, pd.DataFrame]: """ - Helper function for QINI coefficient calculation. See documentation for "evaluate_qini" method - for more details. + Helper function for QINI curve generation and QINI coefficient calculation. + See documentation for "evaluate_qini" method for more details. Parameters ---------- @@ -69,10 +70,12 @@ def calc_qini_coeff( control, e.g. for treatment k the value is Y(k) - Y(0), where 0 signifies no treatment. percentiles: one-dimensional array Array of percentiles over which the QINI curve should be constructed. Defaults to 5%-95% in intervals of 5%. + metric: string + String indicating whether to calculate TOC or QINI; should be one of ['toc', 'qini'] Returns ------- - QINI coefficient and associated standard error. + Uplift coefficient and associated standard error, as well as associated curve. """ qs = np.percentile(cate_preds_train, percentiles) toc, toc_std, group_prob = np.zeros(len(qs)), np.zeros(len(qs)), np.zeros(len(qs)) @@ -82,20 +85,25 @@ def calc_qini_coeff( for it in range(len(qs)): inds = (qs[it] <= cate_preds_val) # group with larger CATE prediction than the q-th quantile group_prob = np.sum(inds) / n # fraction of population in this group - toc[it] = group_prob * ( - np.mean(dr_val[inds]) - ate) # tau(q) = q * E[Y(1) - Y(0) | tau(X) >= q[it]] - E[Y(1) - Y(0)] - toc_psi[it, :] = np.squeeze( - (dr_val - ate) * (inds - group_prob) - toc[it]) # influence function for the tau(q) + if metric == 'qini': + toc[it] = group_prob * ( + np.mean(dr_val[inds]) - ate) # tau(q) = q * E[Y(1) - Y(0) | tau(X) >= q[it]] - E[Y(1) - Y(0)] + toc_psi[it, :] = np.squeeze( + (dr_val - ate) * (inds - group_prob) - toc[it]) # influence function for the tau(q) + else: + toc[it] = np.mean(dr_val[inds]) - ate # tau(q) := E[Y(1) - Y(0) | tau(X) >= q[it]] - E[Y(1) - Y(0)] + toc_psi[it, :] = np.squeeze((dr_val - ate) * (inds / group_prob - 1) - toc[it]) + toc_std[it] = np.sqrt(np.mean(toc_psi[it] ** 2) / n) # standard error of tau(q) - qini_psi = np.sum(toc_psi[:-1] * np.diff(percentiles).reshape(-1, 1) / 100, 0) - qini = np.sum(toc[:-1] * np.diff(percentiles) / 100) - qini_stderr = np.sqrt(np.mean(qini_psi ** 2) / n) + coeff_psi = np.sum(toc_psi[:-1] * np.diff(percentiles).reshape(-1, 1) / 100, 0) + coeff = np.sum(toc[:-1] * np.diff(percentiles) / 100) + coeff_stderr = np.sqrt(np.mean(coeff_psi ** 2) / n) curve_df = pd.DataFrame({ 'Percentage treated': 100 - percentiles, - 'Est. QINI': toc, + 'value': toc, '95_err': 1.96 * toc_std }) - return qini, qini_stderr, curve_df + return coeff, coeff_stderr, curve_df From 30c49336f5983b40de7d097b63c800d7206ee511 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 19 Dec 2023 12:17:47 -0500 Subject: [PATCH 3/9] refactor multi-treatment handling Signed-off-by: amarv --- econml/tests/test_drtester.py | 21 ++++++++++++++---- econml/validate/drtester.py | 27 ++++++++++++----------- econml/validate/results.py | 40 +++++++++++++++++------------------ econml/validate/utils.py | 2 +- 4 files changed, 53 insertions(+), 37 deletions(-) diff --git a/econml/tests/test_drtester.py b/econml/tests/test_drtester.py index 9e890c190..b817bbb88 100644 --- a/econml/tests/test_drtester.py +++ b/econml/tests/test_drtester.py @@ -95,6 +95,12 @@ def test_multi(self): self.assertTrue(str(exc.exception) == 'Plotting only supported for treated units (not controls)') else: self.assertTrue(res.plot_cal(k) is not None) + self.assertTrue(res.plot_qini(k) is not None) + self.assertTrue(res.plot_toc(k) is not None) + + self.assertRaises(ValueError, res.plot_cal, 10) + self.assertRaises(ValueError, res.plot_qini, 10) + self.assertRaises(ValueError, res.plot_toc, 10) self.assertGreater(res_df.blp_pval.values[0], 0.1) # no heterogeneity self.assertLess(res_df.blp_pval.values[1], 0.05) # heterogeneity @@ -103,6 +109,7 @@ def test_multi(self): self.assertGreater(res_df.cal_r_squared.values[1], 0) # good R2 self.assertLess(res_df.qini_pval.values[1], res_df.qini_pval.values[0]) + self.assertLess(res_df.autoc_pval.values[1], res_df.autoc_pval.values[0]) def test_binary(self): Xtrain, Dtrain, Ytrain, Xval, Dval, Yval = self._get_data(num_treatments=1) @@ -143,10 +150,13 @@ def test_binary(self): self.assertTrue(str(exc.exception) == 'Plotting only supported for treated units (not controls)') else: self.assertTrue(res.plot_cal(k) is not None) + self.assertTrue(res.plot_qini(k) is not None) + self.assertTrue(res.plot_toc(k) is not None) self.assertLess(res_df.blp_pval.values[0], 0.05) # heterogeneity self.assertGreater(res_df.cal_r_squared.values[0], 0) # good R2 self.assertLess(res_df.qini_pval.values[0], 0.05) # heterogeneity + self.assertLess(res_df.autoc_pval.values[0], 0.05) # heterogeneity def test_nuisance_val_fit(self): Xtrain, Dtrain, Ytrain, Xval, Dval, Yval = self._get_data(num_treatments=1) @@ -209,7 +219,7 @@ def test_exceptions(self): ) # fit nothing - for func in [my_dr_tester.evaluate_blp, my_dr_tester.evaluate_cal, my_dr_tester.evaluate_qini]: + for func in [my_dr_tester.evaluate_blp, my_dr_tester.evaluate_cal, my_dr_tester.evaluate_uplift]: with self.assertRaises(Exception) as exc: func() if func.__name__ == 'evaluate_cal': @@ -226,7 +236,7 @@ def test_exceptions(self): for func in [ my_dr_tester.evaluate_blp, my_dr_tester.evaluate_cal, - my_dr_tester.evaluate_qini, + my_dr_tester.evaluate_uplift, my_dr_tester.evaluate_all ]: with self.assertRaises(Exception) as exc: @@ -241,7 +251,7 @@ def test_exceptions(self): for func in [ my_dr_tester.evaluate_cal, - my_dr_tester.evaluate_qini, + my_dr_tester.evaluate_uplift, my_dr_tester.evaluate_all ]: with self.assertRaises(Exception) as exc: @@ -259,5 +269,8 @@ def test_exceptions(self): ).fit_nuisance( Xval, Dval, Yval, Xtrain, Dtrain, Ytrain ) - qini_res = my_dr_tester.evaluate_qini(Xval, Xtrain) + qini_res = my_dr_tester.evaluate_uplift(Xval, Xtrain) self.assertLess(qini_res.pvals[0], 0.05) + + autoc_res = my_dr_tester.evaluate_uplift(Xval, Xtrain, metric='toc') + self.assertLess(autoc_res.pvals[0], 0.05) diff --git a/econml/validate/drtester.py b/econml/validate/drtester.py index 13153bd03..fea403b6c 100644 --- a/econml/validate/drtester.py +++ b/econml/validate/drtester.py @@ -382,7 +382,7 @@ def evaluate_cal( self.get_cate_preds(Xval, Xtrain) cal_r_squared = np.zeros(self.n_treat) - df_plot = pd.DataFrame() + plot_dict = dict() for k in range(self.n_treat): cuts = np.quantile(self.cate_preds_train_[:, k], np.linspace(0, 1, n_groups + 1)) probs = np.zeros(n_groups) @@ -409,15 +409,19 @@ def evaluate_cal( # Calculate R-square calibration score cal_r_squared[k] = 1 - (cal_score_g / cal_score_o) - df_plot1 = pd.DataFrame({'ind': np.array(range(n_groups)), - 'gate': gate, 'se_gate': se_gate, - 'g_cate': g_cate, 'se_g_cate': se_g_cate}) - df_plot1['tmt'] = self.treatments[k + 1] - df_plot = pd.concat((df_plot, df_plot1)) + df_plot1 = pd.DataFrame({ + 'ind': np.array(range(n_groups)), + 'gate': gate, + 'se_gate': se_gate, + 'g_cate': g_cate, + 'se_g_cate': se_g_cate + }) + + plot_dict[self.treatments[k + 1]] = df_plot1 self.cal_res = CalibrationEvaluationResults( cal_r_squared=cal_r_squared, - df_plot=df_plot, + plot_dict=plot_dict, treatments=self.treatments ) @@ -524,6 +528,7 @@ def evaluate_uplift( raise Exception('CATE predictions not yet calculated - must provide both Xval, Xtrain') self.get_cate_preds(Xval, Xtrain) + curve_dict = dict() if self.n_treat == 1: coeff, err, curve_df = calc_uplift( self.cate_preds_train_, @@ -534,11 +539,10 @@ def evaluate_uplift( ) coeffs = [coeff] errs = [err] - curve_dfs = [curve_df] + curve_dict[self.treatments[1]] = curve_df else: coeffs = [] errs = [] - curve_dfs = [] for k in range(self.n_treat): coeff, err, curve_df = calc_uplift( self.cate_preds_train_[:, k], @@ -547,10 +551,9 @@ def evaluate_uplift( percentiles, metric ) - coeffs.append(coeff) errs.append(err) - curve_dfs.append(curve_df) + curve_dict[self.treatments[k + 1]] = curve_df pvals = [st.norm.sf(abs(q / e)) for q, e in zip(coeffs, errs)] @@ -559,7 +562,7 @@ def evaluate_uplift( errs=errs, pvals=pvals, treatments=self.treatments, - curve_dfs=curve_dfs + curve_dict=curve_dict ) return self.uplift_res diff --git a/econml/validate/results.py b/econml/validate/results.py index e53b294a0..1be4b4519 100644 --- a/econml/validate/results.py +++ b/econml/validate/results.py @@ -1,7 +1,7 @@ import numpy as np import pandas as pd -from typing import List +from typing import List, Dict, Any class CalibrationEvaluationResults: @@ -22,11 +22,11 @@ class CalibrationEvaluationResults: def __init__( self, cal_r_squared: np.array, - df_plot: pd.DataFrame, + plot_dict: Dict[Any, pd.DataFrame], treatments: np.array ): self.cal_r_squared = cal_r_squared - self.df_plot = df_plot + self.plot_dict = plot_dict self.treatments = treatments def summary(self) -> pd.DataFrame: @@ -48,24 +48,23 @@ def summary(self) -> pd.DataFrame: }).round(3) return res - def plot_cal(self, tmt: int): + def plot_cal(self, tmt: Any): """ Plots group average treatment effects (GATEs) and predicted GATEs by quantile-based group in validation sample. Parameters ---------- - tmt: integer - Treatment level to plot + tmt: Any + Name of treatment to plot Returns ------- matplotlib plot with predicted GATE on x-axis and GATE (and 95% CI) on y-axis """ - if tmt == 0: - raise Exception('Plotting only supported for treated units (not controls)') + if tmt not in self.treatments[1:]: + raise ValueError(f'Invalid treatment; must be one of {self.treatments[1:]}') - df = self.df_plot - df = df[df.tmt == tmt].copy() + df = self.plot_dict[tmt].copy() rsq = round(self.cal_r_squared[np.where(self.treatments == tmt)[0][0] - 1], 3) df['95_err'] = 1.96 * df['se_gate'] fig = df.plot( @@ -156,13 +155,13 @@ def __init__( errs: List[float], pvals: List[float], treatments: np.array, - curve_dfs: List[pd.DataFrame] + curve_dict: Dict[Any, pd.DataFrame] ): self.params = params self.errs = errs self.pvals = pvals self.treatments = treatments - self.curves = curve_dfs + self.curves = curve_dict def summary(self): """ @@ -184,23 +183,24 @@ def summary(self): }).round(3) return res - def plot_uplift(self, tmt: int): + def plot_uplift(self, tmt: Any): """ Plots uplift curves. Parameters ---------- - tmt: integer - Treatment level (index) to plot + tmt: any (sortable) + Name of treatment to plot. Returns ------- matplotlib plot with percentage treated on x-axis and uplift metric (and 95% CI) on y-axis """ - if tmt == 0: - raise Exception('Plotting only supported for treated units (not controls)') + if tmt not in self.treatments[1:]: + raise ValueError(f'Invalid treatment; must be one of {self.treatments[1:]}') - df = self.curves[tmt - 1] + df = self.curves[tmt].copy() + df['95_err'] = 1.96 * df['err'] fig = df.plot( kind='scatter', x='Percentage treated', @@ -252,10 +252,10 @@ def summary(self): pandas dataframe containing summary of all test results """ res = self.blp.summary().merge( - self.qini.summary(), + self.qini.summary().rename({'est': 'qini_est', 'se': 'qini_se', 'pval': 'qini_pval'}, axis=1), on='treatment' ).merge( - self.toc.summary(), + self.toc.summary().rename({'est': 'autoc_est', 'se': 'autoc_se', 'pval': 'autoc_pval'}, axis=1), on='treatment' ).merge( self.cal.summary(), diff --git a/econml/validate/utils.py b/econml/validate/utils.py index aa0c22ed9..a473a0b7d 100644 --- a/econml/validate/utils.py +++ b/econml/validate/utils.py @@ -103,7 +103,7 @@ def calc_uplift( curve_df = pd.DataFrame({ 'Percentage treated': 100 - percentiles, 'value': toc, - '95_err': 1.96 * toc_std + 'err': toc_std }) return coeff, coeff_stderr, curve_df From d769334e2c7336eb3030afd497d20648ac2e3a63 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 19 Dec 2023 12:33:10 -0500 Subject: [PATCH 4/9] update plotting + example notebook Signed-off-by: amarv --- econml/validate/results.py | 4 + notebooks/CATE validation.ipynb | 346 ++++++++++++++++++++++++++------ 2 files changed, 286 insertions(+), 64 deletions(-) diff --git a/econml/validate/results.py b/econml/validate/results.py index 1be4b4519..074860496 100644 --- a/econml/validate/results.py +++ b/econml/validate/results.py @@ -201,12 +201,16 @@ def plot_uplift(self, tmt: Any): df = self.curves[tmt].copy() df['95_err'] = 1.96 * df['err'] + res = self.summary() + coeff = round(res.loc[res['treatment'] == tmt]['est'].values[0], 3) + err = round(res.loc[res['treatment'] == tmt]['se'].values[0], 3) fig = df.plot( kind='scatter', x='Percentage treated', y='value', yerr='95_err', ylabel='Gain over Random', + title=f"Treatment = {tmt}, Integral = {coeff} +/- {err}" ) return fig diff --git a/notebooks/CATE validation.ipynb b/notebooks/CATE validation.ipynb index 57b20444b..c7033a525 100644 --- a/notebooks/CATE validation.ipynb +++ b/notebooks/CATE validation.ipynb @@ -13,44 +13,7 @@ }, "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_clustering.py:35: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _pt_shuffle_rec(i, indexes, index_mask, partition_tree, M, pos):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_clustering.py:54: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def delta_minimization_order(all_masks, max_swap_size=100, num_passes=2):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_clustering.py:63: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _reverse_window(order, start, length):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_clustering.py:69: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _reverse_window_score_gain(masks, order, start, length):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_clustering.py:77: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _mask_delta_score(m1, m2):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/links.py:5: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def identity(x):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/links.py:10: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _identity_inverse(x):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/links.py:15: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def logit(x):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/links.py:20: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _logit_inverse(x):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_masked_model.py:362: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _build_fixed_single_output(averaged_outs, last_outs, outputs, batch_positions, varying_rows, num_varying_rows, link, linearizing_weights):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/utils/_masked_model.py:384: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _build_fixed_multi_output(averaged_outs, last_outs, outputs, batch_positions, varying_rows, num_varying_rows, link, linearizing_weights):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/maskers/_tabular.py:185: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _single_delta_mask(dind, masked_inputs, last_mask, data, x, noop_code):\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/shap/maskers/_tabular.py:196: NumbaDeprecationWarning: The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - " def _delta_masking(masks, x, curr_delta_inds, varying_rows_out,\n", - "/opt/anaconda3/envs/cate_test/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n", - "The 'nopython' keyword argument was not supplied to the 'numba.jit' decorator. The implicit default value for this argument is currently False, but it will be changed to True in Numba 0.59.0. See https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit for details.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", @@ -66,7 +29,6 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false }, @@ -132,7 +94,6 @@ { "cell_type": "markdown", "metadata": { - "collapsed": false, "jupyter": { "outputs_hidden": false }, @@ -166,14 +127,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "`sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n", "The final model has a nonzero intercept for at least one outcome; it will be subtracted, but consider fitting a model without an intercept if possible.\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -229,6 +189,9 @@ " qini_est\n", " qini_se\n", " qini_pval\n", + " autoc_est\n", + " autoc_se\n", + " autoc_pval\n", " cal_r_squared\n", " \n", " \n", @@ -242,6 +205,9 @@ " -0.015\n", " 0.021\n", " 0.242\n", + " -0.032\n", + " 0.063\n", + " 0.306\n", " -5.506\n", " \n", " \n", @@ -253,6 +219,9 @@ " 0.373\n", " 0.024\n", " 0.000\n", + " 1.026\n", + " 0.060\n", + " 0.000\n", " 0.090\n", " \n", " \n", @@ -264,9 +233,9 @@ "0 1 -0.137 0.142 0.335 -0.015 0.021 0.242 \n", "1 2 1.209 0.095 0.000 0.373 0.024 0.000 \n", "\n", - " cal_r_squared \n", - "0 -5.506 \n", - "1 0.090 " + " autoc_est autoc_se autoc_pval cal_r_squared \n", + "0 -0.032 0.063 0.306 -5.506 \n", + "1 1.026 0.060 0.000 0.090 " ] }, "execution_count": 5, @@ -303,7 +272,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -313,7 +282,7 @@ } ], "source": [ - "res_dml.cal.plot_cal(1)" + "res_dml.plot_cal(1)" ] }, { @@ -333,7 +302,127 @@ }, { "data": { - "image/png": "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", + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_dml.plot_cal(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_dml.plot_qini(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_dml.plot_qini(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_dml.plot_toc(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -343,7 +432,7 @@ } ], "source": [ - "res_dml.cal.plot_cal(2)" + "res_dml.plot_toc(2)" ] }, { @@ -355,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": { "collapsed": false, "jupyter": { @@ -394,6 +483,9 @@ " qini_est\n", " qini_se\n", " qini_pval\n", + " autoc_est\n", + " autoc_se\n", + " autoc_pval\n", " cal_r_squared\n", " \n", " \n", @@ -407,6 +499,9 @@ " -0.044\n", " 0.022\n", " 0.023\n", + " -0.083\n", + " 0.057\n", + " 0.071\n", " -2.747\n", " \n", " \n", @@ -418,6 +513,9 @@ " 0.371\n", " 0.025\n", " 0.000\n", + " 1.028\n", + " 0.059\n", + " 0.000\n", " 0.626\n", " \n", " \n", @@ -429,12 +527,12 @@ "0 1 -0.185 0.111 0.096 -0.044 0.022 0.023 \n", "1 2 0.716 0.060 0.000 0.371 0.025 0.000 \n", "\n", - " cal_r_squared \n", - "0 -2.747 \n", - "1 0.626 " + " autoc_est autoc_se autoc_pval cal_r_squared \n", + "0 -0.083 0.057 0.071 -2.747 \n", + "1 1.028 0.059 0.000 0.626 " ] }, - "execution_count": 8, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -453,7 +551,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -462,13 +560,13 @@ "" ] }, - "execution_count": 9, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -478,12 +576,12 @@ } ], "source": [ - "res_t.cal.plot_cal(1)" + "res_t.plot_cal(1)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -492,13 +590,133 @@ "" ] }, - "execution_count": 10, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_t.plot_cal(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_t.plot_qini(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_t.plot_qini(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "res_t.plot_toc(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -508,7 +726,7 @@ } ], "source": [ - "res_t.cal.plot_cal(2)" + "res_t.plot_toc(2)" ] }, { @@ -535,9 +753,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.17" + "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} From 66cbe096c854f5b7f15ac19eb8cb63fd081adbe5 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 19 Dec 2023 13:04:02 -0500 Subject: [PATCH 5/9] update test cases Signed-off-by: amarv --- econml/tests/test_drtester.py | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/econml/tests/test_drtester.py b/econml/tests/test_drtester.py index b817bbb88..105a383c7 100644 --- a/econml/tests/test_drtester.py +++ b/econml/tests/test_drtester.py @@ -88,20 +88,16 @@ def test_multi(self): res = my_dr_tester.evaluate_all(Xval, Xtrain) res_df = res.summary() - for k in range(3): - if k == 0: - with self.assertRaises(Exception) as exc: - res.plot_cal(k) - self.assertTrue(str(exc.exception) == 'Plotting only supported for treated units (not controls)') - else: + for k in range(4): + if k in [0, 3]: + self.assertRaises(ValueError, res.plot_cal, k) + self.assertRaises(ValueError, res.plot_qini, k) + self.assertRaises(ValueError, res.plot_toc, k) + else: # real treatments, k = 1 or 2 self.assertTrue(res.plot_cal(k) is not None) self.assertTrue(res.plot_qini(k) is not None) self.assertTrue(res.plot_toc(k) is not None) - self.assertRaises(ValueError, res.plot_cal, 10) - self.assertRaises(ValueError, res.plot_qini, 10) - self.assertRaises(ValueError, res.plot_toc, 10) - self.assertGreater(res_df.blp_pval.values[0], 0.1) # no heterogeneity self.assertLess(res_df.blp_pval.values[1], 0.05) # heterogeneity @@ -143,12 +139,12 @@ def test_binary(self): res = my_dr_tester.evaluate_all(Xval, Xtrain) res_df = res.summary() - for k in range(2): - if k == 0: - with self.assertRaises(Exception) as exc: - res.plot_cal(k) - self.assertTrue(str(exc.exception) == 'Plotting only supported for treated units (not controls)') - else: + for k in range(3): + if k in [0, 2]: + self.assertRaises(ValueError, res.plot_cal, k) + self.assertRaises(ValueError, res.plot_qini, k) + self.assertRaises(ValueError, res.plot_toc, k) + else: # real treatment, k = 1 self.assertTrue(res.plot_cal(k) is not None) self.assertTrue(res.plot_qini(k) is not None) self.assertTrue(res.plot_toc(k) is not None) From 041bcafaf7c57a05f020af2215c3d6d6017e150f Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 19 Dec 2023 13:30:56 -0500 Subject: [PATCH 6/9] update tests Signed-off-by: amarv --- econml/tests/test_drtester.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/econml/tests/test_drtester.py b/econml/tests/test_drtester.py index 105a383c7..a9766425a 100644 --- a/econml/tests/test_drtester.py +++ b/econml/tests/test_drtester.py @@ -245,6 +245,12 @@ def test_exceptions(self): self.assertTrue(str(exc.exception) == "CATE predictions not yet calculated - must provide both Xval, Xtrain") + with self.assertRaises(Exception) as exc: + my_dr_tester.evaluate_uplift(metric='blah') + self.assertTrue( + str(exc.exception) == "Uplift metric must be one of ['qini', 'toc']" + ) + for func in [ my_dr_tester.evaluate_cal, my_dr_tester.evaluate_uplift, From 19024c4716d4137c2918ce4b7cc89cf6f35fc183 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 9 Jan 2024 11:04:04 -0800 Subject: [PATCH 7/9] fix docstrings + clean up Signed-off-by: amarv --- econml/validate/drtester.py | 16 ++++++++-------- econml/validate/results.py | 24 ++++++++++++++++-------- econml/validate/utils.py | 4 +++- 3 files changed, 27 insertions(+), 17 deletions(-) diff --git a/econml/validate/drtester.py b/econml/validate/drtester.py index fea403b6c..fd3805100 100644 --- a/econml/validate/drtester.py +++ b/econml/validate/drtester.py @@ -382,7 +382,7 @@ def evaluate_cal( self.get_cate_preds(Xval, Xtrain) cal_r_squared = np.zeros(self.n_treat) - plot_dict = dict() + plot_data_dict = dict() for k in range(self.n_treat): cuts = np.quantile(self.cate_preds_train_[:, k], np.linspace(0, 1, n_groups + 1)) probs = np.zeros(n_groups) @@ -409,7 +409,7 @@ def evaluate_cal( # Calculate R-square calibration score cal_r_squared[k] = 1 - (cal_score_g / cal_score_o) - df_plot1 = pd.DataFrame({ + df_plot = pd.DataFrame({ 'ind': np.array(range(n_groups)), 'gate': gate, 'se_gate': se_gate, @@ -417,11 +417,11 @@ def evaluate_cal( 'se_g_cate': se_g_cate }) - plot_dict[self.treatments[k + 1]] = df_plot1 + plot_data_dict[self.treatments[k + 1]] = df_plot self.cal_res = CalibrationEvaluationResults( cal_r_squared=cal_r_squared, - plot_dict=plot_dict, + plot_data_dict=plot_data_dict, treatments=self.treatments ) @@ -528,7 +528,7 @@ def evaluate_uplift( raise Exception('CATE predictions not yet calculated - must provide both Xval, Xtrain') self.get_cate_preds(Xval, Xtrain) - curve_dict = dict() + curve_data_dict = dict() if self.n_treat == 1: coeff, err, curve_df = calc_uplift( self.cate_preds_train_, @@ -539,7 +539,7 @@ def evaluate_uplift( ) coeffs = [coeff] errs = [err] - curve_dict[self.treatments[1]] = curve_df + curve_data_dict[self.treatments[1]] = curve_df else: coeffs = [] errs = [] @@ -553,7 +553,7 @@ def evaluate_uplift( ) coeffs.append(coeff) errs.append(err) - curve_dict[self.treatments[k + 1]] = curve_df + curve_data_dict[self.treatments[k + 1]] = curve_df pvals = [st.norm.sf(abs(q / e)) for q, e in zip(coeffs, errs)] @@ -562,7 +562,7 @@ def evaluate_uplift( errs=errs, pvals=pvals, treatments=self.treatments, - curve_dict=curve_dict + curve_data_dict=curve_data_dict ) return self.uplift_res diff --git a/econml/validate/results.py b/econml/validate/results.py index 074860496..d236757a7 100644 --- a/econml/validate/results.py +++ b/econml/validate/results.py @@ -13,8 +13,9 @@ class CalibrationEvaluationResults: cal_r_squared: list or numpy array of floats Sequence of calibration R^2 values - df_plot: pandas dataframe - Dataframe containing necessary data for plotting calibration test GATE results + plot_data_dict: dict + Dictionary mapping treatment levels to dataframes containing necessary + data for plotting calibration test GATE results treatments: list or numpy array of floats Sequence of treatment labels @@ -22,11 +23,11 @@ class CalibrationEvaluationResults: def __init__( self, cal_r_squared: np.array, - plot_dict: Dict[Any, pd.DataFrame], + plot_data_dict: Dict[Any, pd.DataFrame], treatments: np.array ): self.cal_r_squared = cal_r_squared - self.plot_dict = plot_dict + self.plot_data_dict = plot_data_dict self.treatments = treatments def summary(self) -> pd.DataFrame: @@ -64,7 +65,7 @@ def plot_cal(self, tmt: Any): if tmt not in self.treatments[1:]: raise ValueError(f'Invalid treatment; must be one of {self.treatments[1:]}') - df = self.plot_dict[tmt].copy() + df = self.plot_data_dict[tmt].copy() rsq = round(self.cal_r_squared[np.where(self.treatments == tmt)[0][0] - 1], 3) df['95_err'] = 1.96 * df['se_gate'] fig = df.plot( @@ -148,6 +149,10 @@ class UpliftEvaluationResults: treatments: list or numpy array of floats Sequence of treatment labels + + curve_data_dict: dict + Dictionary mapping treatment levels to dataframes containing + necessary data for plotting uplift curves """ def __init__( self, @@ -155,13 +160,13 @@ def __init__( errs: List[float], pvals: List[float], treatments: np.array, - curve_dict: Dict[Any, pd.DataFrame] + curve_data_dict: Dict[Any, pd.DataFrame] ): self.params = params self.errs = errs self.pvals = pvals self.treatments = treatments - self.curves = curve_dict + self.curves = curve_data_dict def summary(self): """ @@ -228,8 +233,11 @@ class EvaluationResults: blp_res: BLPEvaluationResults object Results object for BLP test - qini_res: QiniEvaluationResults object + qini_res: UpliftEvaluationResults object Results object for QINI test + + toc_res: UpliftEvaluationResults object + Results object for TOC test """ def __init__( self, diff --git a/econml/validate/utils.py b/econml/validate/utils.py index a473a0b7d..8cd69cae8 100644 --- a/econml/validate/utils.py +++ b/econml/validate/utils.py @@ -90,9 +90,11 @@ def calc_uplift( np.mean(dr_val[inds]) - ate) # tau(q) = q * E[Y(1) - Y(0) | tau(X) >= q[it]] - E[Y(1) - Y(0)] toc_psi[it, :] = np.squeeze( (dr_val - ate) * (inds - group_prob) - toc[it]) # influence function for the tau(q) - else: + elif metric == 'toc': toc[it] = np.mean(dr_val[inds]) - ate # tau(q) := E[Y(1) - Y(0) | tau(X) >= q[it]] - E[Y(1) - Y(0)] toc_psi[it, :] = np.squeeze((dr_val - ate) * (inds / group_prob - 1) - toc[it]) + else: + raise ValueError("Unsupported metric! Must be one of ['toc', 'qini']") toc_std[it] = np.sqrt(np.mean(toc_psi[it] ** 2) / n) # standard error of tau(q) From 41c4068b6cb7314e569c083c35b6186c40e8403b Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 9 Jan 2024 11:06:42 -0800 Subject: [PATCH 8/9] change uplift metric error handling Signed-off-by: amarv --- econml/validate/drtester.py | 3 --- econml/validate/utils.py | 2 +- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/econml/validate/drtester.py b/econml/validate/drtester.py index fd3805100..bcf4c0141 100644 --- a/econml/validate/drtester.py +++ b/econml/validate/drtester.py @@ -520,9 +520,6 @@ def evaluate_uplift( if not hasattr(self, 'dr_val_'): raise Exception("Must fit nuisances before evaluating") - if not (metric in ['qini', 'toc']): - raise ValueError("Uplift metric must be one of ['qini', 'toc']") - if (not hasattr(self, 'cate_preds_train_')) or (not hasattr(self, 'cate_preds_val_')): if (Xval is None) or (Xtrain is None): raise Exception('CATE predictions not yet calculated - must provide both Xval, Xtrain') diff --git a/econml/validate/utils.py b/econml/validate/utils.py index 8cd69cae8..50dc3235d 100644 --- a/econml/validate/utils.py +++ b/econml/validate/utils.py @@ -94,7 +94,7 @@ def calc_uplift( toc[it] = np.mean(dr_val[inds]) - ate # tau(q) := E[Y(1) - Y(0) | tau(X) >= q[it]] - E[Y(1) - Y(0)] toc_psi[it, :] = np.squeeze((dr_val - ate) * (inds / group_prob - 1) - toc[it]) else: - raise ValueError("Unsupported metric! Must be one of ['toc', 'qini']") + raise ValueError("Unsupported metric - must be one of ['toc', 'qini']") toc_std[it] = np.sqrt(np.mean(toc_psi[it] ** 2) / n) # standard error of tau(q) From 078630a40e2b6317154aba93383455ad93e4f143 Mon Sep 17 00:00:00 2001 From: amarv Date: Tue, 9 Jan 2024 11:20:20 -0800 Subject: [PATCH 9/9] Update test cases Signed-off-by: amarv --- econml/tests/test_drtester.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/econml/tests/test_drtester.py b/econml/tests/test_drtester.py index a9766425a..7e0775274 100644 --- a/econml/tests/test_drtester.py +++ b/econml/tests/test_drtester.py @@ -245,12 +245,6 @@ def test_exceptions(self): self.assertTrue(str(exc.exception) == "CATE predictions not yet calculated - must provide both Xval, Xtrain") - with self.assertRaises(Exception) as exc: - my_dr_tester.evaluate_uplift(metric='blah') - self.assertTrue( - str(exc.exception) == "Uplift metric must be one of ['qini', 'toc']" - ) - for func in [ my_dr_tester.evaluate_cal, my_dr_tester.evaluate_uplift, @@ -264,6 +258,12 @@ def test_exceptions(self): cal_res = my_dr_tester.evaluate_cal(Xval, Xtrain) self.assertGreater(cal_res.cal_r_squared[0], 0) # good R2 + with self.assertRaises(Exception) as exc: + my_dr_tester.evaluate_uplift(metric='blah') + self.assertTrue( + str(exc.exception) == "Unsupported metric - must be one of ['toc', 'qini']" + ) + my_dr_tester = DRtester( model_regression=reg_y, model_propensity=reg_t,