From 9c31b554cbed694e688fb4d5590940ad5acc04f0 Mon Sep 17 00:00:00 2001 From: Eduardo Souza Date: Fri, 26 Aug 2022 10:34:50 -0300 Subject: [PATCH] Causal T-learner (#206) * Included initial Meta S-learner classifier code. * Included references in docstring. * Fixed numpy typing. * Removed unused import * Created new type to allow mutable features, which is required with S-learner specifically. * Fixed types based on new created type. * Removed unused import. * Requires learner to be mandatory. * Removed lgbm import * meta_learners.py: converted _predict_for_treatment and _predict_for_control functions into single _predict_by_treatment_flag function. * Renamed LearnerMutableFeaturesFnType to LearnerMutableParametersFnType. * included tests * Fixed docstring and handled case in which uplift is negative. * fix lint * removed unused imports - wip * added test__simulate_treatment_effect * fix assertions * fix assert_frame_equal * meta_learners.py: included control_name parameter in _simulate_treatment_effect call. * Included custom exceptions. * meta_learner.py: Included exception checks in some functions. * meta_learners.py: fixed bug. Changed treatment_col by treatment_name * included assertion tests * updated predict_by_treatment_flag test functions to test only the treatment value (1 or 0) * added tests for causal_s_classification_learner * changed function test name * included explanation to test__simulate_treatment_effect * moved column drop from simulate_treatment_effect to predict_by_treatment_flag * changed mock learner for a mock function at test__simulate_treatment_effect * included test for learners being the correct type * meta_learners.py: fixed replace to x.replace(__uplift, ) * test_meta_learners.py: fixed test__simulate_treatment_effect to adapt change in replace on previous commit. * meta_learners.py: fixed description of prediction_column in docstring. * causal_s_learner_demo.ipynb: included demo notebook for causal s-learner. * causal_s_learner_demo.ipynb: fixed notebook headers. * Rerun notebook. * causal_s_learner_demo.ipynb: included documentation in the notebook. * Improved notebook description. * Initial commit of T-Learner * Add docstring * Lint * Change _get_model_fcn return type * Fix learner type * Removed unused import * Removed unused import * Updated types * Fix variables naming * Added tests * Lint * Type fix * Improve documentation of T-Learner Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Fixed t-learner docstring Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Fixed t-learner docstring Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Fixed t-learner parameter type Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Fixed t-learner docstring Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Fix t-learner argument type Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Improve T-Learner types Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Remove unused type Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Add SHAP to logs Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> * Update src/fklearn/causal/cate_learning/meta_learners.py * Applied review comments * Update demo notebook * Merged with master and included rst * Fix test * Update t-learner notebook Co-authored-by: Giulio Santo Co-authored-by: Nicolas Behar Co-authored-by: Giulio Cesare Mastrocinque Santo <32403782+GiulioCMSanto@users.noreply.github.com> --- .../api/fklearn.causal.cate_learning.rst | 22 + notebooks/causal_s_learner_demo.ipynb | 2 +- notebooks/causal_t_learner_demo.ipynb | 2434 +++++++++++++++++ .../causal/cate_learning/meta_learners.py | 201 +- .../cate_learning/test_meta_learners.py | 266 +- 5 files changed, 2867 insertions(+), 58 deletions(-) create mode 100644 docs/source/api/fklearn.causal.cate_learning.rst create mode 100644 notebooks/causal_t_learner_demo.ipynb diff --git a/docs/source/api/fklearn.causal.cate_learning.rst b/docs/source/api/fklearn.causal.cate_learning.rst new file mode 100644 index 00000000..35888232 --- /dev/null +++ b/docs/source/api/fklearn.causal.cate_learning.rst @@ -0,0 +1,22 @@ +fklearn.causal.cate\_learning package +===================================== + +Submodules +---------- + +fklearn.causal.cate\_learning.double\_machine\_learning module +-------------------------------------------------------------- + +.. automodule:: fklearn.causal.cate_learning.double_machine_learning + :members: + :undoc-members: + :show-inheritance: + + +Module contents +--------------- + +.. automodule:: fklearn.causal.cate_learning + :members: + :undoc-members: + :show-inheritance: diff --git a/notebooks/causal_s_learner_demo.ipynb b/notebooks/causal_s_learner_demo.ipynb index ab017263..d5cb5b8f 100644 --- a/notebooks/causal_s_learner_demo.ipynb +++ b/notebooks/causal_s_learner_demo.ipynb @@ -2439,4 +2439,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/notebooks/causal_t_learner_demo.ipynb b/notebooks/causal_t_learner_demo.ipynb new file mode 100644 index 00000000..fe848b5e --- /dev/null +++ b/notebooks/causal_t_learner_demo.ipynb @@ -0,0 +1,2434 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f84aeac6", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T17:38:44.522833Z", + "start_time": "2022-08-01T17:38:44.516580Z" + } + }, + "source": [ + "## Causal T-Learner Classifier\n", + "\n", + "### TL; DR\n", + "---\n", + "This notebooks exemplifies how one can use the causal T-learner through fklearn.\n", + "\n", + "### Long\n", + "---\n", + "A very interesting and useful type of causal models are uplift models, in which one is able to identify how each sample responds to a given treatment, and what is the effect of that treatment compared to a control group. The main goal of uplift models is, therefore, to learn the difference in probability of a sample converting (using a product), given that it was submitted to some action (nudge). Meta-learns are examples of causal models, in which the CATE represents how each unit will respond to a given treatment [1]. In fact, the uplift can be understood as the incremental gain in the conversion probability in the case a given sample was in the treatment group instead of the control one. In addition, these models have the advantage of using conventional machine learning models, such as LightGBM.\n", + "\n", + "More specifically, the T-Learner is a meta-learner which learns the Conditional Average Treatment Effect (CATE) through the use of multiple models, one for each treatment. Each model is fitted in a subset of the data, according to the treatment. The CATE $\\tau$ is defined as $\\tau(x_{i}) = M_{1}(X=x_{i}, T=1) - M_{0}(X=x_{i}, T=0)$, being $M_{1}$ a model fitted with treatment data and $M_{0}$ a model fitted with control data, and they can be a Machine Learning Model such as a LightGBM Classifier and $x_{i}$ the feature set of sample $i$.\n", + "\n", + "### Data\n", + "---\n", + "The data here adopted is provided in [1], [2].\n", + "\n", + "### References\n", + "---\n", + "\n", + "[1] https://matheusfacure.github.io/python-causality-handbook/21-Meta-Learners.html\n", + "\n", + "[2] https://github.com/matheusfacure/python-causality-handbook/tree/master/causal-inference-for-the-brave-and-true/data\n", + "\n", + "[3] https://causalml.readthedocs.io/en/latest/methodology.html" + ] + }, + { + "cell_type": "markdown", + "id": "651c52e1", + "metadata": {}, + "source": [ + "### 1. Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "209dd195", + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b9ae70be", + "metadata": {}, + "outputs": [], + "source": [ + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "909075ef", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/eduardo.souza/dev/nu/fklearn/src'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "os.chdir(\"../src\")\n", + "os.getcwd()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "334c24ac", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:54.942876Z", + "start_time": "2022-08-01T21:08:52.183053Z" + } + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from fklearn.causal.cate_learning.meta_learners import causal_t_classification_learner\n", + "from fklearn.training.classification import lgbm_classification_learner\n", + "from fklearn.training.calibration import isotonic_calibration_learner\n", + "from fklearn.causal.validation.curves import cumulative_gain_curve\n", + "from fklearn.training.pipeline import build_pipeline\n", + "from fklearn.training.transformation import ecdfer\n", + "\n", + "sns.set_style(\"darkgrid\")" + ] + }, + { + "cell_type": "markdown", + "id": "7951044d", + "metadata": {}, + "source": [ + "### 2. Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3b3820cf", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:54.949172Z", + "start_time": "2022-08-01T21:08:54.944256Z" + } + }, + "outputs": [], + "source": [ + "def plot_cumulative_gain_curve(\n", + " train_gain: np.ndarray,\n", + " test_gain: np.ndarray,\n", + " random_gain: np.ndarray,\n", + " fontsize: int = 16,\n", + " figsize: tuple = (15,5)\n", + ") -> None:\n", + " \"\"\"\n", + " Plots the cumulative gain curve.\n", + " \"\"\"\n", + "\n", + " xaxis = np.arange(len(train_gain))/len(train_gain)\n", + " \n", + " plt.figure(figsize=figsize);\n", + " plt.plot(xaxis, train_gain, label=\"Training Data\");\n", + " plt.plot(xaxis, test_gain, label=\"Testing Data\");\n", + " plt.plot(xaxis, random_gain, \"--\", label=\"Random\");\n", + " \n", + " plt.ylabel(\"Cumulative Gain\", fontsize=fontsize);\n", + " plt.xlabel(\"Population Proportion\", fontsize=fontsize);\n", + " plt.title(\"Cumulative Gain Curve\", fontsize=fontsize);\n", + " \n", + " plt.legend(fontsize=fontsize);\n", + " plt.xticks(fontsize=fontsize);\n", + " plt.yticks(fontsize=fontsize);" + ] + }, + { + "cell_type": "markdown", + "id": "1bb4b598", + "metadata": {}, + "source": [ + "### 3. Read Data" + ] + }, + { + "cell_type": "markdown", + "id": "99ced58c", + "metadata": {}, + "source": [ + "Notice that the data here adopted is provided in [1] and [2]." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "164af8a7", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.654415Z", + "start_time": "2022-08-01T21:08:54.952419Z" + } + }, + "outputs": [], + "source": [ + "test_data = pd.read_csv(\n", + " \"https://raw.githubusercontent.com/matheusfacure/python-causality-handbook/master/causal-inference-for-the-brave-and-true/data/invest_email_rnd.csv\"\n", + ")\n", + "train_data = pd.read_csv(\n", + " \"https://raw.githubusercontent.com/matheusfacure/python-causality-handbook/master/causal-inference-for-the-brave-and-true/data/invest_email_biased.csv\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "c4100764", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.665495Z", + "start_time": "2022-08-01T21:08:55.656451Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(15000, 8)" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "9dbc21fd", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.671480Z", + "start_time": "2022-08-01T21:08:55.667548Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(15000, 8)" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.shape" + ] + }, + { + "cell_type": "markdown", + "id": "bfba7573", + "metadata": {}, + "source": [ + "#### 3.1 Include Treatment Column" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "bed6542e", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.684291Z", + "start_time": "2022-08-01T21:08:55.673873Z" + } + }, + "outputs": [], + "source": [ + "train_data[\"control\"] = np.where((train_data[\"em1\"]+train_data[\"em2\"]+train_data[\"em3\"])==0,1,0)\n", + "train_data[\"treatment_col\"] = train_data[[\"em1\",\"em2\",\"em3\",\"control\"]].idxmax(axis=1).values\n", + "\n", + "test_data[\"control\"] = np.where((test_data[\"em1\"]+test_data[\"em2\"]+test_data[\"em3\"])==0,1,0)\n", + "test_data[\"treatment_col\"] = test_data[[\"em1\",\"em2\",\"em3\",\"control\"]].idxmax(axis=1).values" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b951bc0c", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.701127Z", + "start_time": "2022-08-01T21:08:55.686721Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageincomeinsuranceinvestedem1em2em3convertedcontroltreatment_col
044.15483.806155.2914294.8100100em3
139.82737.9250069.407468.1510000em1
249.02712.515707.085095.6500110em3
339.72326.3715657.976345.2000001control
435.32787.2627074.4414114.8611000em1
\n", + "
" + ], + "text/plain": [ + " age income insurance invested em1 em2 em3 converted control \\\n", + "0 44.1 5483.80 6155.29 14294.81 0 0 1 0 0 \n", + "1 39.8 2737.92 50069.40 7468.15 1 0 0 0 0 \n", + "2 49.0 2712.51 5707.08 5095.65 0 0 1 1 0 \n", + "3 39.7 2326.37 15657.97 6345.20 0 0 0 0 1 \n", + "4 35.3 2787.26 27074.44 14114.86 1 1 0 0 0 \n", + "\n", + " treatment_col \n", + "0 em3 \n", + "1 em1 \n", + "2 em3 \n", + "3 control \n", + "4 em1 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2dc0eb3e", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.717300Z", + "start_time": "2022-08-01T21:08:55.703374Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageincomeinsuranceinvestedem1em2em3convertedcontroltreatment_col
044.15483.806155.2914294.8101100em2
139.82737.9250069.407468.1510000em1
249.02712.515707.085095.6510110em1
339.72326.3715657.976345.2011100em1
435.32787.2627074.4414114.8611100em1
\n", + "
" + ], + "text/plain": [ + " age income insurance invested em1 em2 em3 converted control \\\n", + "0 44.1 5483.80 6155.29 14294.81 0 1 1 0 0 \n", + "1 39.8 2737.92 50069.40 7468.15 1 0 0 0 0 \n", + "2 49.0 2712.51 5707.08 5095.65 1 0 1 1 0 \n", + "3 39.7 2326.37 15657.97 6345.20 1 1 1 0 0 \n", + "4 35.3 2787.26 27074.44 14114.86 1 1 1 0 0 \n", + "\n", + " treatment_col \n", + "0 em2 \n", + "1 em1 \n", + "2 em1 \n", + "3 em1 \n", + "4 em1 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_data.head()" + ] + }, + { + "cell_type": "markdown", + "id": "b02dd80c", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T17:34:49.478324Z", + "start_time": "2022-08-01T17:34:49.472616Z" + } + }, + "source": [ + "### 4. Causal T-Learner" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f2e41cb9", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.727534Z", + "start_time": "2022-08-01T21:08:55.724439Z" + } + }, + "outputs": [], + "source": [ + "target_column = \"converted\"\n", + "features = [\"age\", \"income\", \"insurance\", \"invested\"]\n", + "treatment_column = \"treatment_col\"\n", + "control_name = \"control\"\n", + "prediction_column = \"prediction\"" + ] + }, + { + "cell_type": "markdown", + "id": "f13a389d", + "metadata": {}, + "source": [ + "#### 4.1 Using T-Learner with LightGBM" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "86154394", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.732761Z", + "start_time": "2022-08-01T21:08:55.729735Z" + } + }, + "outputs": [], + "source": [ + "clf_learner = lgbm_classification_learner(\n", + " features = features,\n", + " target = target_column,\n", + " prediction_column = prediction_column\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "885a539f", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:55.738793Z", + "start_time": "2022-08-01T21:08:55.735586Z" + } + }, + "outputs": [], + "source": [ + "t_learner = causal_t_classification_learner(\n", + " treatment_col=treatment_column,\n", + " control_name=control_name,\n", + " prediction_column=prediction_column,\n", + " learner=clf_learner,\n", + " treatment_learner=clf_learner,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e2d4cd23", + "metadata": {}, + "source": [ + "**Training the model**" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "68c21ad5", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.027747Z", + "start_time": "2022-08-01T21:08:55.740932Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n", + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n", + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[LightGBM] [Info] Number of positive: 504, number of negative: 3808\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000434 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 963\n", + "[LightGBM] [Info] Number of data points in the train set: 4312, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.116883 -> initscore=-2.022283\n", + "[LightGBM] [Info] Start training from score -2.022283\n", + "[LightGBM] [Info] Number of positive: 1392, number of negative: 5088\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000334 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 898\n", + "[LightGBM] [Info] Number of data points in the train set: 6480, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.214815 -> initscore=-1.296143\n", + "[LightGBM] [Info] Start training from score -1.296143\n", + "[LightGBM] [Info] Number of positive: 802, number of negative: 2568\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000364 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 958\n", + "[LightGBM] [Info] Number of data points in the train set: 3370, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.237982 -> initscore=-1.163774\n", + "[LightGBM] [Info] Start training from score -1.163774\n", + "[LightGBM] [Info] Number of positive: 309, number of negative: 529\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000133 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 906\n", + "[LightGBM] [Info] Number of data points in the train set: 838, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.368735 -> initscore=-0.537647\n", + "[LightGBM] [Info] Start training from score -0.537647\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n" + ] + } + ], + "source": [ + "t_learner_fcn, t_learner_train_df, t_learner_log = t_learner(train_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "629ee628", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.034377Z", + "start_time": "2022-08-01T21:08:56.030279Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + ".p(new_df: pandas.core.frame.DataFrame) -> pandas.core.frame.DataFrame>" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t_learner_fcn" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bb863168", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.051585Z", + "start_time": "2022-08-01T21:08:56.036919Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageincomeinsuranceinvestedem1em2em3convertedcontroltreatment_coltreatment_em3__prediction_on_treatmenttreatment_em3__uplifttreatment_em1__prediction_on_treatmenttreatment_em1__uplifttreatment_em2__prediction_on_treatmenttreatment_em2__upliftupliftsuggested_treatment
044.15483.806155.2914294.8100100em30.2595510.0798250.4479920.2682650.3083170.1285900.268265treatment_em1
139.82737.9250069.407468.1510000em10.091645-0.0037860.063676-0.0317550.015090-0.080341-0.003786control
249.02712.515707.085095.6500110em30.4644480.4180730.6826840.6363090.0612110.0148360.636309treatment_em1
339.72326.3715657.976345.2000001control0.0861450.0367140.2565010.2070710.1967680.1473380.207071treatment_em1
435.32787.2627074.4414114.8611000em10.1497710.1403580.2014140.1920010.0822540.0728420.192001treatment_em1
\n", + "
" + ], + "text/plain": [ + " age income insurance invested em1 em2 em3 converted control \\\n", + "0 44.1 5483.80 6155.29 14294.81 0 0 1 0 0 \n", + "1 39.8 2737.92 50069.40 7468.15 1 0 0 0 0 \n", + "2 49.0 2712.51 5707.08 5095.65 0 0 1 1 0 \n", + "3 39.7 2326.37 15657.97 6345.20 0 0 0 0 1 \n", + "4 35.3 2787.26 27074.44 14114.86 1 1 0 0 0 \n", + "\n", + " treatment_col treatment_em3__prediction_on_treatment \\\n", + "0 em3 0.259551 \n", + "1 em1 0.091645 \n", + "2 em3 0.464448 \n", + "3 control 0.086145 \n", + "4 em1 0.149771 \n", + "\n", + " treatment_em3__uplift treatment_em1__prediction_on_treatment \\\n", + "0 0.079825 0.447992 \n", + "1 -0.003786 0.063676 \n", + "2 0.418073 0.682684 \n", + "3 0.036714 0.256501 \n", + "4 0.140358 0.201414 \n", + "\n", + " treatment_em1__uplift treatment_em2__prediction_on_treatment \\\n", + "0 0.268265 0.308317 \n", + "1 -0.031755 0.015090 \n", + "2 0.636309 0.061211 \n", + "3 0.207071 0.196768 \n", + "4 0.192001 0.082254 \n", + "\n", + " treatment_em2__uplift uplift suggested_treatment \n", + "0 0.128590 0.268265 treatment_em1 \n", + "1 -0.080341 -0.003786 control \n", + "2 0.014836 0.636309 treatment_em1 \n", + "3 0.147338 0.207071 treatment_em1 \n", + "4 0.072842 0.192001 treatment_em1 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t_learner_train_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "ae0405f3", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.059283Z", + "start_time": "2022-08-01T21:08:56.054044Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'causal_t_classification_learner': {'control': {'lgbm_classification_learner': {'features': ['age',\n", + " 'income',\n", + " 'insurance',\n", + " 'invested'],\n", + " 'target': 'converted',\n", + " 'prediction_column': 'prediction',\n", + " 'package': 'lightgbm',\n", + " 'package_version': '3.3.2',\n", + " 'parameters': {'eta': 0.1, 'objective': 'binary', 'num_estimators': 100},\n", + " 'feature_importance': {'age': 739,\n", + " 'income': 811,\n", + " 'insurance': 724,\n", + " 'invested': 726},\n", + " 'training_samples': 4312,\n", + " 'running_time': '0.087 s'},\n", + " 'object': },\n", + " 'em3': {'lgbm_classification_learner': {'features': ['age',\n", + " 'income',\n", + " 'insurance',\n", + " 'invested'],\n", + " 'target': 'converted',\n", + " 'prediction_column': 'prediction',\n", + " 'package': 'lightgbm',\n", + " 'package_version': '3.3.2',\n", + " 'parameters': {'eta': 0.1, 'objective': 'binary', 'num_estimators': 100},\n", + " 'feature_importance': {'age': 627,\n", + " 'income': 772,\n", + " 'insurance': 816,\n", + " 'invested': 785},\n", + " 'training_samples': 6480,\n", + " 'running_time': '0.064 s'},\n", + " 'object': },\n", + " 'em1': {'lgbm_classification_learner': {'features': ['age',\n", + " 'income',\n", + " 'insurance',\n", + " 'invested'],\n", + " 'target': 'converted',\n", + " 'prediction_column': 'prediction',\n", + " 'package': 'lightgbm',\n", + " 'package_version': '3.3.2',\n", + " 'parameters': {'eta': 0.1, 'objective': 'binary', 'num_estimators': 100},\n", + " 'feature_importance': {'age': 769,\n", + " 'income': 747,\n", + " 'insurance': 748,\n", + " 'invested': 736},\n", + " 'training_samples': 3370,\n", + " 'running_time': '0.051 s'},\n", + " 'object': },\n", + " 'em2': {'lgbm_classification_learner': {'features': ['age',\n", + " 'income',\n", + " 'insurance',\n", + " 'invested'],\n", + " 'target': 'converted',\n", + " 'prediction_column': 'prediction',\n", + " 'package': 'lightgbm',\n", + " 'package_version': '3.3.2',\n", + " 'parameters': {'eta': 0.1, 'objective': 'binary', 'num_estimators': 100},\n", + " 'feature_importance': {'age': 618,\n", + " 'income': 745,\n", + " 'insurance': 801,\n", + " 'invested': 835},\n", + " 'training_samples': 838,\n", + " 'running_time': '0.085 s'},\n", + " 'object': }}}" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t_learner_log" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2ed58ac7", + "metadata": {}, + "outputs": [], + "source": [ + "score_of_interest = \"treatment_em1__uplift\"" + ] + }, + { + "cell_type": "markdown", + "id": "dadfd813", + "metadata": {}, + "source": [ + "**Making Predictions**" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "19c87675", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.138488Z", + "start_time": "2022-08-01T21:08:56.061810Z" + } + }, + "outputs": [], + "source": [ + "t_learner_test_df = t_learner_fcn(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d992f3c8", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.155056Z", + "start_time": "2022-08-01T21:08:56.141081Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageincomeinsuranceinvestedem1em2em3convertedcontroltreatment_coltreatment_em3__prediction_on_treatmenttreatment_em3__uplifttreatment_em1__prediction_on_treatmenttreatment_em1__uplifttreatment_em2__prediction_on_treatmenttreatment_em2__upliftupliftsuggested_treatment
044.15483.806155.2914294.8101100em20.2595510.0798250.4479920.2682650.3083170.1285900.268265treatment_em1
139.82737.9250069.407468.1510000em10.091645-0.0037860.063676-0.0317550.015090-0.080341-0.003786control
249.02712.515707.085095.6510110em10.4644480.4180730.6826840.6363090.0612110.0148360.636309treatment_em1
339.72326.3715657.976345.2011100em10.0861450.0367140.2565010.2070710.1967680.1473380.207071treatment_em1
435.32787.2627074.4414114.8611100em10.1497710.1403580.2014140.1920010.0822540.0728420.192001treatment_em1
\n", + "
" + ], + "text/plain": [ + " age income insurance invested em1 em2 em3 converted control \\\n", + "0 44.1 5483.80 6155.29 14294.81 0 1 1 0 0 \n", + "1 39.8 2737.92 50069.40 7468.15 1 0 0 0 0 \n", + "2 49.0 2712.51 5707.08 5095.65 1 0 1 1 0 \n", + "3 39.7 2326.37 15657.97 6345.20 1 1 1 0 0 \n", + "4 35.3 2787.26 27074.44 14114.86 1 1 1 0 0 \n", + "\n", + " treatment_col treatment_em3__prediction_on_treatment \\\n", + "0 em2 0.259551 \n", + "1 em1 0.091645 \n", + "2 em1 0.464448 \n", + "3 em1 0.086145 \n", + "4 em1 0.149771 \n", + "\n", + " treatment_em3__uplift treatment_em1__prediction_on_treatment \\\n", + "0 0.079825 0.447992 \n", + "1 -0.003786 0.063676 \n", + "2 0.418073 0.682684 \n", + "3 0.036714 0.256501 \n", + "4 0.140358 0.201414 \n", + "\n", + " treatment_em1__uplift treatment_em2__prediction_on_treatment \\\n", + "0 0.268265 0.308317 \n", + "1 -0.031755 0.015090 \n", + "2 0.636309 0.061211 \n", + "3 0.207071 0.196768 \n", + "4 0.192001 0.082254 \n", + "\n", + " treatment_em2__uplift uplift suggested_treatment \n", + "0 0.128590 0.268265 treatment_em1 \n", + "1 -0.080341 -0.003786 control \n", + "2 0.014836 0.636309 treatment_em1 \n", + "3 0.147338 0.207071 treatment_em1 \n", + "4 0.072842 0.192001 treatment_em1 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t_learner_test_df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "60a1bfb9", + "metadata": {}, + "source": [ + "**Create Random Score**" + ] + }, + { + "cell_type": "markdown", + "id": "196a3a23", + "metadata": {}, + "source": [ + "Let's also create a random score that can be used to compute the Cumulative Gain curve." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "61728dd6", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.162206Z", + "start_time": "2022-08-01T21:08:56.157333Z" + } + }, + "outputs": [], + "source": [ + "random_score_df = test_data[[\"em1\", target_column]].copy()\n", + "random_score_df[score_of_interest] = np.random.uniform(0,1,random_score_df.shape[0])" + ] + }, + { + "cell_type": "markdown", + "id": "b5b65182", + "metadata": {}, + "source": [ + "**Checking Cumulative Gain Curve**" + ] + }, + { + "cell_type": "markdown", + "id": "c18d8dc7", + "metadata": {}, + "source": [ + "For more details about causal models evaluation, please look at the following reference:\n", + "\n", + "https://matheusfacure.github.io/python-causality-handbook/19-Evaluating-Causal-Models.html?highlight=gain%20curve " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "dada0b5c", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.167642Z", + "start_time": "2022-08-01T21:08:56.164515Z" + } + }, + "outputs": [], + "source": [ + "gain_curve = cumulative_gain_curve(\n", + " treatment = \"em1\",\n", + " outcome = target_column,\n", + " prediction = score_of_interest\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "44ac0567", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.479996Z", + "start_time": "2022-08-01T21:08:56.170218Z" + } + }, + "outputs": [], + "source": [ + "gain_curve_train = gain_curve(t_learner_train_df)\n", + "gain_curve_test = gain_curve(t_learner_test_df)\n", + "gain_curve_random = gain_curve(random_score_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e0f39cfc", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.695829Z", + "start_time": "2022-08-01T21:08:56.481931Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_cumulative_gain_curve(\n", + " train_gain = gain_curve_train,\n", + " test_gain = gain_curve_test,\n", + " random_gain = gain_curve_random\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "16b67daa", + "metadata": {}, + "source": [ + "#### 4.2 Using T-Learner with Fklearn Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "5adc2f2f", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.701600Z", + "start_time": "2022-08-01T21:08:56.698546Z" + } + }, + "outputs": [], + "source": [ + "cdf = ecdfer(\n", + " prediction_column=score_of_interest\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "a995e275", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.705705Z", + "start_time": "2022-08-01T21:08:56.703511Z" + } + }, + "outputs": [], + "source": [ + "pipeline = build_pipeline(\n", + " *[t_learner, cdf]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "21db9ef8", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.885605Z", + "start_time": "2022-08-01T21:08:56.707835Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n", + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[LightGBM] [Info] Number of positive: 504, number of negative: 3808\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000739 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 963\n", + "[LightGBM] [Info] Number of data points in the train set: 4312, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.116883 -> initscore=-2.022283\n", + "[LightGBM] [Info] Start training from score -2.022283\n", + "[LightGBM] [Info] Number of positive: 1392, number of negative: 5088\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000108 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 898\n", + "[LightGBM] [Info] Number of data points in the train set: 6480, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.214815 -> initscore=-1.296143\n", + "[LightGBM] [Info] Start training from score -1.296143\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n", + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[LightGBM] [Info] Number of positive: 802, number of negative: 2568\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000157 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 958\n", + "[LightGBM] [Info] Number of data points in the train set: 3370, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.237982 -> initscore=-1.163774\n", + "[LightGBM] [Info] Start training from score -1.163774\n", + "[LightGBM] [Info] Number of positive: 309, number of negative: 529\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000331 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 906\n", + "[LightGBM] [Info] Number of data points in the train set: 838, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.368735 -> initscore=-0.537647\n", + "[LightGBM] [Info] Start training from score -0.537647\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n" + ] + } + ], + "source": [ + "pipe_fcn, pipe_train_df, pipe_log = pipeline(\n", + " train_data\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "08b227a5", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:56.901902Z", + "start_time": "2022-08-01T21:08:56.887944Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageincomeinsuranceinvestedem1em2em3convertedcontroltreatment_coltreatment_em3__prediction_on_treatmenttreatment_em3__uplifttreatment_em1__prediction_on_treatmenttreatment_em1__uplifttreatment_em2__prediction_on_treatmenttreatment_em2__upliftupliftsuggested_treatmentprediction_ecdf
044.15483.806155.2914294.8100100em30.2595510.0798250.4479920.2682650.3083170.1285900.268265treatment_em1754.266667
139.82737.9250069.407468.1510000em10.091645-0.0037860.063676-0.0317550.015090-0.080341-0.003786control110.066667
249.02712.515707.085095.6500110em30.4644480.4180730.6826840.6363090.0612110.0148360.636309treatment_em1989.133333
339.72326.3715657.976345.2000001control0.0861450.0367140.2565010.2070710.1967680.1473380.207071treatment_em1653.533333
435.32787.2627074.4414114.8611000em10.1497710.1403580.2014140.1920010.0822540.0728420.192001treatment_em1622.666667
\n", + "
" + ], + "text/plain": [ + " age income insurance invested em1 em2 em3 converted control \\\n", + "0 44.1 5483.80 6155.29 14294.81 0 0 1 0 0 \n", + "1 39.8 2737.92 50069.40 7468.15 1 0 0 0 0 \n", + "2 49.0 2712.51 5707.08 5095.65 0 0 1 1 0 \n", + "3 39.7 2326.37 15657.97 6345.20 0 0 0 0 1 \n", + "4 35.3 2787.26 27074.44 14114.86 1 1 0 0 0 \n", + "\n", + " treatment_col treatment_em3__prediction_on_treatment \\\n", + "0 em3 0.259551 \n", + "1 em1 0.091645 \n", + "2 em3 0.464448 \n", + "3 control 0.086145 \n", + "4 em1 0.149771 \n", + "\n", + " treatment_em3__uplift treatment_em1__prediction_on_treatment \\\n", + "0 0.079825 0.447992 \n", + "1 -0.003786 0.063676 \n", + "2 0.418073 0.682684 \n", + "3 0.036714 0.256501 \n", + "4 0.140358 0.201414 \n", + "\n", + " treatment_em1__uplift treatment_em2__prediction_on_treatment \\\n", + "0 0.268265 0.308317 \n", + "1 -0.031755 0.015090 \n", + "2 0.636309 0.061211 \n", + "3 0.207071 0.196768 \n", + "4 0.192001 0.082254 \n", + "\n", + " treatment_em2__uplift uplift suggested_treatment prediction_ecdf \n", + "0 0.128590 0.268265 treatment_em1 754.266667 \n", + "1 -0.080341 -0.003786 control 110.066667 \n", + "2 0.014836 0.636309 treatment_em1 989.133333 \n", + "3 0.147338 0.207071 treatment_em1 653.533333 \n", + "4 0.072842 0.192001 treatment_em1 622.666667 " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipe_train_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "3f0ae64f", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.152815Z", + "start_time": "2022-08-01T21:08:56.904019Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEPCAYAAACHuClZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2XUlEQVR4nO3deVhV1d4H8C+DoOcckBTTrhNO4IR4HEDEFBwIh7qllyxFwgn15iwqNzT0kkClKDkwlKhl7y1T1O7Vur2As4hjWg5oKCmWBA7IAQk4rPcPHvbLkcMg+wBH/X6eh+eBtdfa53cWm/Njr7X32iZCCAEiIiIZTBs6ACIievoxmRARkWxMJkREJBuTCRERycZkQkREsjGZkNHihYa115B9x9/b84nJhPSaNGkSZsyYoXfb5cuX4eDggJSUlBrvLzAwEGPGjJF+dnBwwObNm6WfN2/ejAEDBqB3797Yt28fEhISEBwcXO1+k5OTMXXqVPTv3x+Ojo7w8vLC2rVrodFoahxbfVu/fj0cHBykr65du0KtVsPb2xtfffWVzodxRkYGHBwc8P3339do33fu3MHUqVNx//79KuuV//2mpKTAwcEBP/30U+3fFICHDx9i0aJFuHjxolT2+O+Znl3mDR0APZ++/vpr/OUvfwEA5Obm4uOPP8bo0aPx9ttvo2PHjpg3bx4UCkWV+zh06BBmzpyJsWPHwsfHB40bN8bly5cRExODlJQUfPnllzAzM6uPt/PEGjdujG3btgEASkpKkJOTg6SkJKxYsQKXLl3CP//5TwDAiy++iK+//hp2dnY12u/x48dx9OjRausFBwfD1NSw/0tevnwZ//nPf+Dn5yeVlf8907ONyYQaRO/evaXvHz58CCEEhg8fjn79+tV4H5999hnc3NywatUqqczV1RUdO3bEjBkzcPToUQwZMsSQYRuMqampTh8AgIeHB2xtbbFp0yaMHDkSrq6usLCwqFDPEDp37mzwfepTF7GTceIwF8m2fv16jBkzBnv37oWHhwfUajVmzJiBjIyMStuUDX/Ex8dj6NChAID58+dj6NChmDRpEk6ePImDBw/CwcGh0v3cu3dP7/i8m5sbFixYgJYtW0plt2/fxrx58+Ds7AxnZ2fMmTMHv/32m7Q9IyMD8+bNg6urK9RqNWbNmoX09HSd9zh27FiEhoaiT58+eP311wEAxcXFiIyMhLu7OxwdHTF27FgkJyc/SffpmDZtGpo0aYKdO3dKcZUf5srPz0dQUBAGDRqEXr164Y033sAPP/wAAIiPj8c//vEPAKVJdf369VL7bdu2YejQoejbty9Onz6tdxjz4sWLGDt2rPQ+jh07Jm2Lj4+Hg4MD7t27J5U9fPgQDg4OiI+PR0pKCnx9fQEAf/vb3xAYGAig4jDXlStXMG3aNOn3sHjxYmRnZ0vbAwMDMXfuXGzbtg0eHh7o1asXJk2ahLS0tFr3KdUPJhMyiNu3b+Ojjz7C7NmzERYWhuvXr8PPzw+FhYVVtnN3d8eGDRsAAAsXLsSGDRsQHByM7t27o0+fPvj666/x4osv6m07ePBgHD16FDNnzsS+ffuQlZUFAGjUqBFmzpyJrl27AgA0Gg0mTJiA1NRUBAcHIzw8HNevX8f06dOh1Wpx584deHt749dff8WKFSsQFhaGjIwMTJgwAZmZmdLrpaam4sqVK9i4cSPmz58PAFi+fDm2bNkCX19fbNy4ER07dsT06dNx9uzZWvWjUqmEo6Mjzp07p3f7qlWrcOLECQQFBSE2NhadOnXCvHnzkJaWBnd3d8yaNQtA6Vmbt7e31G7Tpk0ICAjA8uXL0atXL737Dg0NxfDhw7FhwwbY2tpixowZOvMfVenRowfef/99AEBYWBj+/ve/V6hz+fJljB8/HkVFRQgPD8d7772H06dPw8fHB/n5+VK948ePY8+ePQgKCsLHH3+MX3/9VUpOZLw4zEUGkZ+fj8jISAwePBgA0LFjR7z22mvYt28f3njjjUrbNWvWDN26dQMAtG/fHt27dwcAqFQqKBSKKodJFixYgAcPHmDPnj04cOCA9LqvvPIKJk+ejKZNmwIAdu3ahezsbHz//fdo27YtAOCll17Cu+++i+vXr2PXrl0oKChAXFwcmjVrBgBwdnbG8OHDsWXLFumDrLi4GIGBgVKMaWlpiI+PxwcffCB9cA8ePBhZWVlYt24dPv/881r1ZfPmzXH+/Hm9286cOQM3NzeMHDkSANCnTx/Y2tqiuLgYzZo1Q7t27QCUfrg3a9ZMOqt79dVXMWrUqCpfd8qUKVIScHV1xYgRI7BlyxasXr262phVKpU0dNalSxcpjvI2bdqEZs2a4dNPP4WFhQUAoGfPnnj11Vexa9cuTJo0CQCQl5eHmJgY6Z+IzMxMrFq1Cvfv38cLL7xQbSzUMHhmQrVmYmIifW9lZSUlEgCwt7dH27Ztcfr06Tp7fQsLC4SFheHAgQMIDg7GiBEjcPfuXURFRWHMmDG4desWAODcuXPo3LmzlEgAoFu3bkhKSkKXLl1w6tQpuLi4SIkEKE1yrq6uOHnypM5rlp8IL9s2ePBgFBcXS19DhgzB2bNnqz0rq41+/fphx44dmDlzJr7++mvcv38fgYGBcHBwqLJdhw4dqt33K6+8In1vYWGBQYMG1foMS59Tp05h2LBhUiIBSuduHBwccOrUKansL3/5i87ZaKtWrQAAjx49MlgsZHg8MyG9mjRpUumHYVFREYDSK5LKtGjRokK9Zs2aIScnp24CLKdVq1aYMGECJkyYgOLiYuzduxfBwcHYsGEDPvzwQ+Tk5KB58+aVtn/48KF0dlRe8+bN8csvv0g/KxQKnSvMHjx4AAA6SbS8+/fv68zb1FRmZmal7ZYtW4YXX3wRe/fuxYEDB2BqaoohQ4YgNDRUJxnqey/VebxOs2bNkJub+2TBV+Hhw4d642jevLnOpdxNmjTR2V521VlJSYnBYiHD45kJ6dW8eXOdidHy7ty5AwCwtbWVyso+WMu7e/dulR9wcvz4448YOHBgheEgc3NzjBs3DkOGDJEmba2srHQmjsscOnQI2dnZaNq0qd73mp2dDRsbm0pjsLKygomJCb7++mvs3LmzwldthmQ0Gg0uXryIvn376t3euHFjzJ07F4mJifjuu+8wd+5cHDt2DJGRkU/8Wo97+PChzs/Z2dnS76/sLLT8BQ/l5zlqomnTprh7926F8ur6mZ4OTCakV//+/fHLL7/ovYomISEBrVu31rl/4N69e7hw4YL085UrV3Dr1i0MGDCgVq9f3T0QdnZ2yMvL0zsvodVqcevWLXTp0gUAoFarce3aNdy+fVuqk5aWBn9/f1y5cgV9+/ZFSkqKTsK5d+8ekpOT0adPn0pj6Nu3L4QQ0Gg0cHR0lL6Sk5OxdetWmJs/+Yn/1q1b8eeff+pMnpd/X2PGjMHWrVsBlM4PzZo1C71798bvv/8OoPp+q8qRI0ek7wsKCnD48GE4OzsDKJ0TAYA//vhDqvP4EGZ19/T07dsXiYmJOme8aWlpuHr1apX9TE8HDnORXmPGjMGWLVswZcoUzJgxA507d8bdu3eRkJCA/fv3Y82aNTr1TUxMMH/+fAQEBAAA1q5di27dusHT07NWr29tbY3Lly8jJSUFTk5OOkNqAGBjY4MFCxYgLCwMDx48wBtvvIFWrVrhjz/+wFdffYXMzEzpKrFx48Zh69atmDFjBubMmQMzMzNERkaiV69eGDBgADp16oTdu3djypQp0tVQUVFRsLCwwDvvvFNpjN26dcMrr7yCxYsXY/bs2ejUqRNOnjyJqKgoTJs2rcoP9pKSEvz444/S9w8ePMDBgwexY8cOTJo0Se+ZiZmZGXr16oWNGzfC0tISHTt2xPnz53HmzBmsXLlS6jcA+N///V+4ubnVvMMBxMTEwNLSEq1bt0ZcXBwePXqE6dOnAwBcXFxgaWmJVatWYdasWfjtt9+kPipjZWUFoPSMT6FQoFOnTjr7nzlzJt566y1Mnz4dfn5+yM3Nxbp169C6dWvpUmt6ejGZkF4WFhb48ssvsWHDBsTFxSEzMxMKhQJdu3ZFbGwsXn75ZZ36TZo0wezZsxEaGoqCggJ4eHjgvffeq9V/5wDg5+eHBQsWYNq0adi2bZve/1z9/PzQvn17bN++HR988AFyc3PxwgsvSDcylk24W1tbY/v27QgPD0dgYCAsLCwwePBgBAYGwtzcHC+99BK+/PJLfPzxxwgMDISZmRlcXFywdu1aafK3MqtXr0ZkZCRiY2Nx9+5dtG7dGosWLcLUqVOrbFdQUIDx48dLPyuVStjb22PVqlUYN25cpe2WLVsGhUKB6Oho6fWWLl0qncm4urpi0KBBCAkJwZtvvokpU6ZUGUd5K1euxPr16/Hrr7+iR48e+Pzzz6WrsqytrbFu3TqsXr0aM2bMQJcuXfDRRx/h3Xffldp36dIFf/3rXxETE4Off/4Z0dHROvvv2bMntm3bhoiICMybNw9NmjTBkCFDsHjxYunMh55eJnxsL8m1fv16xMXFVXpvBBE9+zhnQkREsjGZEBGRbBzmIiIi2XhmQkREsj0zV3OVlJRAq63dSZaZmUmt2zYUxlw/GHP9YMz14/GYhRCwsDBMGnhmkolWK/DgwZPdkVvGxkZR67YNhTHXD8ZcPxhz/dAXc4sWVgbZN4e5iIhINiYTIiKSjcmEiIhke+JkkpiYCLVarVNWUFCAtWvXYsSIEVCr1Xj99dexf/9+nTqFhYUIDQ2Fm5sb1Go15s6dq/MUOwDIyclBYGAgXFxc0L9/fwQFBeksTU1ERMbpiSbgz549i8WLF1coX7FiBRISEjB//nx07NgRSUlJWLBgAQBIT3cLDg5GUlISli5dCoVCgYiICPj7+yM+Pl5abXTOnDnIyMjAihUrUFBQgI8++gjZ2dmIiYmR+z6JiKgO1SiZFBYWYtu2bYiMjIRCoZAejgSUPrNi9+7dOo8uHThwIG7evIm4uDiMGjUKN2/exJ49e7BmzRopuXTt2hVeXl5ITEyEp6cnTpw4gZSUFOzYsQNOTk4ASh965Ofnh4sXL6JHjx6Gfu9ERGQgNRrmOnz4MGJjY7FkyRL4+PjobMvPz8dbb72FQYMG6ZR36NBBev70iRMnAADu7u7Sdjs7O3Tp0kV6hkJycjKaN28uJRKgdNlrlUql85wFIiIyPjVKJo6OjkhMTISvr6/Oc78BoG3btli5ciVeeuklqUyr1eLw4cPo2LEjAODGjRuwtbXVeeQpALRp0wbp6elSnbLlrqXgTE3RunVrqQ4RERmnGiWTli1bSg/dqYlPPvkE169fx7Rp0wAAeXl5UCqVFeoplUppgr0mdYiIyDgZ/A742NhYREdHY8qUKRg6dCiA0lv2Hz+jKVP+2dKVPZmuJo8iNTMzgY2Notp6+tua1rptQ2HM9aMhYtYCaNyo4iNwC4q0qPrBuKXYz/WDMesyWDIRQiA8PBxbt27FhAkTsGTJEmmbSqVCXl5ehTZ5eXnSoz5VKhWysrL01unQoUO1r8/lVIwfY66ZFi2sYBe4r0J5evhoZGXlVtue/Vw/npWYjWo5lZKSEixZsgRbt27FzJkzERwcrHMmYmdnh+zsbBQUFOi0y8jIkBKFnZ0dbt26VWG/t2/frlEyISKihmOQZBIeHo5vv/0WgYGB0v0l5bm6ukKr1SIpKUkqS09Px7Vr1+Dq6irVycrKwoULF6Q6KSkp0Gg0Uh0iIjJOsoe5Ll68iM8//1y6s/3HH3+UtpmamqJXr15o164dvLy8sHz5cmg0GlhbWyMiIgIODg4YPnw4AGDAgAFwcnLC7NmzsWTJEhQXF+PDDz+Eu7s7evbsKTdMIiKqQ7KTSVJSEoQQOHbsGI4dO6azTaFQ4Ny5cwCAsLAwhIWFYfXq1SgpKcHAgQMRFBQk3f1uYmKCqKgohISEYPny5bCwsMCwYcPw3nvvyQ2RiIjq2DPz2N6iIi0n4I0cY64ZTsA/HZ6VmI1qAp6IiJ5vTCZERCQbkwkREcnGZEJERLIxmRARkWxMJkREJBuTCRERycZkQkREsjGZEBGRbEwmREQkm8EfjkVENaOyboImlvwTpGcDj2SiBtLE0rzSNbiInjYc5iIiItmYTIiISDYmEyIiko1zJkRPiYIird5nTzz6sxiah48aICKi/8dkQvSUaNzIrNIJe00DxENUHoe5iIhINiYTIiKSjcmEiIhkYzIhIiLZmEyIiEi2J04miYmJUKvVOmVCCERFRcHd3R1OTk6YPHky0tLSdOoUFhYiNDQUbm5uUKvVmDt3LjIzM3Xq5OTkIDAwEC4uLujfvz+CgoKg0fA6FSIiY/dEyeTs2bNYvHhxhfKNGzciKioKU6ZMQUREBHJzc+Hn54fc3FypTnBwMPbu3YtFixYhLCwMV65cgb+/P7RarVRnzpw5OHnyJFasWIH33nsPSUlJWLRokYy3R0RE9aFG95kUFhZi27ZtiIyMhEKhQFFRkbRNo9Fg8+bNmD17Nnx9fQEA/fr1g4eHB3bu3InJkyfj5s2b2LNnD9asWYNRo0YBALp27QovLy8kJibC09MTJ06cQEpKCnbs2AEnJycAQKtWreDn54eLFy+iR48ehn7vRERkIDU6Mzl8+DBiY2OxZMkS+Pj46Gw7f/488vPzMWzYMKmsadOmcHZ2xpEjRwAAJ06cAAC4u7tLdezs7NClSxepTnJyMpo3by4lEgBwcXGBSqWS6hARkXGqUTJxdHREYmIifH19YWJiorMtPT0dANC2bVud8jZt2kjbbty4AVtbWygUiirrtGvXTjc4U1O0bt1aqkNERMapRsNcLVu2rHSbRqOBhYUFLCwsdMqVSqU0eZ6XlwelUlmhrVKpxJ07d6qtU5NJeDMzE9jYKKqtp7+taa3bNhTGXD+ehpj1rdlV9nNBkRZmDRHUE3oa+vlxjFmX7LW5hBAVzlbKlJXXtI6pqf4TpcrKy9NqBR48yK9JyBXY2Chq3bahMOb6YYiY6/qJipWt2QWUrtuVlZWrd5sxeV6PjfqmL2Z9i4fWhuwj3MrKCoWFhSgqKkKjRo2k8ry8PFhZlQapUqmQl5dXoe3jdbKysvTW6dChg9wwiRoMn6hIzwPZNy22b98eQghkZGTolGdkZEhJwM7ODtnZ2SgoKKiyzq1bt3S2l5SU4Pbt20wmRERGTnYyUavVsLS0REJCglSWk5ODkydPwtXVFQDg6uoKrVaLpKQkqU56ejquXbumUycrKwsXLlyQ6qSkpECj0Uh1iIjIOMke5lIqlfDx8UFkZCRMTU1hZ2eH6OhoqFQqeHt7AwDatWsHLy8vLF++HBqNBtbW1oiIiICDgwOGDx8OABgwYACcnJwwe/ZsLFmyBMXFxfjwww/h7u6Onj17yg2TiIjqkEFmBRcuXAhTU1PExcUhPz8farUa4eHh0nwIAISFhSEsLAyrV69GSUkJBg4ciKCgIJiZlV5rYmJigqioKISEhGD58uWwsLDAsGHD8N577xkiRCIiqkNPnEzmzJmDOXPm6O7E3BwBAQEICAiotJ1CoUBISAhCQkIqrdO8eXOsW7fuSUMiIqIGxlWDiYhINiYTIiKSjcmEiIhkYzIhIiLZmEyIiEi2ulswiIganL5FIAHg0Z/F0Dx81AAR0bOKyYToGVbZIpDp4aPBB2KTIXGYi4iIZGMyISIi2ZhMiIhINiYTIiKSjcmEiIhkYzIhIiLZmEyIiEg2JhMiIpKNyYSIiGRjMiEiItm4nArRc4hrdpGhMZkQPYe4ZhcZGoe5iIhINiYTIiKSjcmEiIhkM1gy0Wq1+PTTTzFixAio1Wp4e3sjOTlZ2i6EQFRUFNzd3eHk5ITJkycjLS1NZx+FhYUIDQ2Fm5sb1Go15s6di8zMTEOFSEREdcRgyWTz5s1Yu3Ytxo0bh40bN6Jdu3aYPn06Ll26BADYuHEjoqKiMGXKFERERCA3Nxd+fn7Izc2V9hEcHIy9e/di0aJFCAsLw5UrV+Dv7w+tVmuoMImIqA4Y7Gqu3bt3Y8yYMZg5cyYAwMXFBWfOnMHOnTuxcOFCbN68GbNnz4avry8AoF+/fvDw8MDOnTsxefJk3Lx5E3v27MGaNWswatQoAEDXrl3h5eWFxMREeHp6GipUIiIyMIOdmRQWFkKlUkk/m5mZwcrKCjk5OTh//jzy8/MxbNgwaXvTpk3h7OyMI0eOAABOnDgBAHB3d5fq2NnZoUuXLlIdIiIyTgZLJhMnTsTevXuRnJyM3NxcbNu2DdeuXcOoUaOQnp4OAGjbtq1OmzZt2kjbbty4AVtbWygUikrrEBGRcTLYMNfbb7+NEydOwM/PTyqbP38+hg0bhpiYGFhYWMDCwkKnjVKphEZTeotUXl4elEplhf0qlUrcuXOn2tc3MzOBjY2i2nr625rWum1DYcz142mMWa6GeL9PYz8zZl0GSSZCCEydOhVpaWkIDg5Gp06dcPz4cWzcuBHW1tYQQsDExERv27LymtSpilYr8OBBfq3it7FR1LptQ2HM9cMQMetbtsSYNcTv6Hk9NuqbvpgNdXwaJJmcOXMGZ86cwbp16zBy5EgApRPwWq0WH3/8MRYsWIDCwkIUFRWhUaNGUru8vDxYWZW+EZVKhby8vAr7Ll+HiIiMk0HmTMqGoXr37q1T3rdvXzx69AgmJiYQQiAjI0Nne0ZGBjp06ACgdLI9OzsbBQUFldYhIiLjZJBkYmdnBwA4e/asTvn58+dhbm4OT09PWFpaIiEhQdqWk5ODkydPwtXVFQDg6uoKrVaLpKQkqU56ejquXbsm1SEiIuNkkGGunj17wt3dHStXrsSDBw/QqVMnnDx5Ep999hl8fX3RqlUr+Pj4IDIyEqamprCzs0N0dDRUKhW8vb0BAO3atYOXlxeWL18OjUYDa2trREREwMHBAcOHDzdEmEREVEcMdjVXZGQk1q1bh+joaOTk5KB9+/YICgrCW2+9BQBYuHAhTE1NERcXh/z8fKjVaoSHh+vMh4SFhSEsLAyrV69GSUkJBg4ciKCgIJiZmRkqTKI6o7JugiaWfKoDPZ8MduQ3btwYgYGBCAwM1P9C5uYICAhAQEBApftQKBQICQlBSEiIocIiqjdNLM0rfUYI0bOOqwYTEZFsTCZERCQbkwkREcnGZEJERLIxmRARkWxMJkREJBsviiciSUGRVu/Cf4/+LIbm4aMGiIieFkwmRCRp3Mis0ntlNA0QDz09OMxFRESyMZkQEZFsTCZERCQbkwkREcnGCXgiqhav8qLqMJkQUbV4lRdVh8NcREQkG5MJERHJxmRCRESyMZkQEZFsTCZERCQbkwkREcnGZEJERLIZNJkkJyfD29sbvXr1goeHBz755BNotVoAgBACUVFRcHd3h5OTEyZPnoy0tDSd9oWFhQgNDYWbmxvUajXmzp2LzMxMQ4ZIRER1wGDJ5MyZM5g+fTo6deqEmJgYTJw4EZ9++imioqIAABs3bkRUVBSmTJmCiIgI5Obmws/PD7m5udI+goODsXfvXixatAhhYWG4cuUK/P39pYRERETGyWB3wK9ZswZubm4IDw8HALi6uuLBgwdISUmBn58fNm/ejNmzZ8PX1xcA0K9fP3h4eGDnzp2YPHkybt68iT179mDNmjUYNWoUAKBr167w8vJCYmIiPD09DRUqEREZmEHOTO7du4ezZ8/izTff1CkPCAjAF198gfPnzyM/Px/Dhg2TtjVt2hTOzs44cuQIAODEiRMAAHd3d6mOnZ0dunTpItUhIuNStmbX418q6yYNHRrVM4OcmaSmpkIIAYVCgZkzZ+LYsWNQqVSYMGEC3n33XaSnpwMA2rZtq9OuTZs2SEpKAgDcuHEDtra2UCgUFeqUtSci48I1u6iMQZLJ/fv3AQBLlizBmDFj4Ofnh1OnTiEqKgqWlpYQQsDCwgIWFhY67ZRKJTSa0kMuLy8PSqWywr6VSiXu3LlTbQxmZiawsVFUW09/W9Nat20ojLl+PI0xG4sn6bensZ8Zsy6DJJOioiIAwKBBg7B06VIAwIABA3D//n1ERUXB398fJiYmetuWlQshqq1TFa1W4MGD/NqEDxsbRa3bNhTGXD+eJGZ9S7Q/z57kd/2sHxvGQl/MhjpuDTJnUnZG8fLLL+uUDxw4EPn5+bC2tkZhYaGUdMrk5eXByqr0jahUKuTl5VXYd/k6RERknAySTNq1awcAFZJFcXExAMDc3BxCCGRkZOhsz8jIQIcOHQCUTrZnZ2ejoKCg0jpERGScDJJMOnfujJYtW+L777/XKT906BBefPFFjB49GpaWlkhISJC25eTk4OTJk3B1dQVQeimxVquVJuQBID09HdeuXZPqEBGRcTLInImpqSkWLlyIpUuXIjg4GF5eXjh+/Dh2796NFStWQKVSwcfHB5GRkTA1NYWdnR2io6OhUqng7e0NoPTsxsvLC8uXL4dGo4G1tTUiIiLg4OCA4cOHGyJMIiKqIwa7afH111+Hubk5YmJiEB8fj5deegkrV67E+PHjAQALFy6Eqakp4uLikJ+fD7VajfDwcJ35kLCwMISFhWH16tUoKSnBwIEDERQUBDMzM0OFSUREdcCgz4AfM2YMxowZo/+FzM0REBCAgICAStsrFAqEhIQgJCTEkGEREVEd46rBREQkG5MJERHJxmRCRESyMZkQEZFsBp2AJyIC/n814cc9+rMYmoePGiAiqmtMJkRkcFxN+PnDYS4iIpKNyYSIiGRjMiEiItmYTIiISDZOwBM9IZV1EzSx5J8OUXn8iyB6Qk0szSu9UonoecVhLiIiko3JhIiIZOMwFxHVm8rujC8o0jZANGRITCZEVG+qujM+twHiIcPhMBcREcnGZEJERLIxmRARkWxMJkREJBuTCRERycZkQkREshk8mRQWFmLkyJEIDAyUyoQQiIqKgru7O5ycnDB58mSkpaVVaBcaGgo3Nzeo1WrMnTsXmZmZhg6PiIxQ2f0nj3+prJs0dGhUQwa/z2TDhg24fv06nJycpLKNGzciNjYWAQEBaN26NaKiouDn54f9+/fDyqr0Bqbg4GAkJSVh6dKlUCgUiIiIgL+/P+Lj42FmZmboMInIiPDJjE8/gyaTS5cu4YsvvsALL7wglWk0GmzevBmzZ8+Gr68vAKBfv37w8PDAzp07MXnyZNy8eRN79uzBmjVrMGrUKABA165d4eXlhcTERHh6ehoyTCIiMjCDDXMVFxfjvffew9SpU9GyZUup/Pz588jPz8ewYcOksqZNm8LZ2RlHjhwBAJw4cQIA4O7uLtWxs7NDly5dpDpERGS8DJZMPv30UxQVFcHf31+nPD09HQDQtm1bnfI2bdpI227cuAFbW1soFIpK6xARkfEyyDBXWloaoqOjsXXrVlhYWOhs02g0sLCwqFCuVCqh0ZSOhubl5UGpVFbYr1KpxJ07d2oUg5mZCWxsFNVX1NvWtNZtGwpjrh9PY8zPGmPt/6fx2KjLmGUnk5KSEgQFBeFvf/sb1Gp1he1CCJiYmOhtW1ZekzrV0WoFHjzIr2HUumxsFLVu21AYc/3QF7O+VW+p7hjrMcPjWZfsZPLFF1/g999/R2xsLIqLi6VyIQSKi4thZWWFwsJCFBUVoVGjRtL2vLw86UoulUqFvLy8CvsuX4eIiIyX7DmThIQE3LlzB/3790ePHj3Qo0cPXLlyBXv27EGPHj1gbm4OIQQyMjJ02mVkZKBDhw4ASifbs7OzUVBQUGkdIiIyXrKTycqVK7Fz506dLzs7O+nS39GjR8PS0hIJCQlSm5ycHJw8eRKurq4AAFdXV2i1WiQlJUl10tPTce3aNakOEREZL9nDXB07dqxQ1rhxY9jY2MDR0REA4OPjg8jISJiamsLOzg7R0dFQqVTw9vYGALRr1w5eXl5Yvnw5NBoNrK2tERERAQcHBwwfPlxuiEREVMfq5UmLCxcuhKmpKeLi4pCfnw+1Wo3w8HCd+ZCwsDCEhYVh9erVKCkpwcCBAxEUFMS736nBqKyboFEjM064N6DKHvP76M9iaB4+aoCIqDJ1kkz27t2r+yLm5ggICEBAQEClbRQKBUJCQhASElIXIRE9sSaW5pUu8UH1g8usPD24ajAREcnGZEJERLIxmRARkWxMJkREJBuTCRERycZkQkREsjGZEBGRbEwmREQkG5MJERHJxmRCRESy1cvaXEREhlTZml0FRVo0blRxPT+u5VX3mEyI6KlT1ZpdXMurYXCYi4iIZGMyISIi2ZhMiIhINiYTIiKSjcmEiIhkYzIhIiLZmEyIiEg23mdCRM+8ym5yBHhDo6EwmRDRM6+ymxwB3tBoKAYb5tJqtdiyZQtGjhyJ3r17Y9SoUdi+fTuEEAAAIQSioqLg7u4OJycnTJ48GWlpaTr7KCwsRGhoKNzc3KBWqzF37lxkZmYaKkQiIqojBjsz2bRpE2JjY/H3v/8dvXv3xunTpxEaGopHjx5h+vTp2LhxI2JjYxEQEIDWrVsjKioKfn5+2L9/P6ysSk8/g4ODkZSUhKVLl0KhUCAiIgL+/v6Ij4+HmVnF9XaIDEFl3QRNLHmSTiSHQf6Cys5Kpk6dilmzZgEAXF1dce/ePcTFxeHtt9/G5s2bMXv2bPj6+gIA+vXrBw8PD+zcuROTJ0/GzZs3sWfPHqxZswajRo0CAHTt2hVeXl5ITEyEp6enIUIlqqCJpXml6zkRUc0YZJhLo9Hg9ddfr/CB36FDB9y7dw8nTpxAfn4+hg0bJm1r2rQpnJ2dceTIEQDAiRMnAADu7u5SHTs7O3Tp0kWqQ0RkaGWT849/qaybNHRoTxWDnJk0bdoU77//foXyAwcOoFWrVtK8R9u2bXW2t2nTBklJSQCAGzduwNbWFgqFokKd9PR0Q4RJRFRBVSsQc2K+5upsoPibb77B8ePHsWzZMmg0GlhYWMDCwkKnjlKphEZT+uvKy8uDUqmssB+lUok7d+5U+3pmZiawsVFUW09/W9Nat20ojJmo7lV1vD6Nx3NdxlwnyeTbb79FcHAwXnnlFfj4+CAmJgYmJiZ665aVCyGqrVMVrVbgwYP8WsVrY6OodduGwpgNp7L7D4iqOl6N9Xiuir6YDXX8GzyZbNmyBR9++CGGDh2K1atXw8TEBFZWVigsLERRUREaNWok1c3Ly5Ou5FKpVMjLy6uwv/J1iIjqS2U3OvImR/0MmkwiIiIQExOD119/HatWrYK5eenu27dvDyEEMjIy0KFDB6l++Z/t7OyQnZ2NgoICNG7cWKdO3759DRkmEVG1OJfyZAx20+K2bdsQExMDX19fhIeHS4kEANRqNSwtLZGQkCCV5eTk4OTJk3B1dQVQeimxVquVJuQBID09HdeuXZPqEBGRcTLImckff/yB1atXw97eHqNHj8b58+d1tvfs2RM+Pj6IjIyEqakp7OzsEB0dDZVKBW9vbwBAu3bt4OXlheXLl0Oj0cDa2hoRERFwcHDA8OHDDREmERHVEYMkk6NHj6KwsBBXr17F+PHjK2xPTk7GwoULYWpqiri4OOTn50OtViM8PFxnPiQsLAxhYWFYvXo1SkpKMHDgQAQFBfHudyIiI2eQZDJ27FiMHTu22noBAQEICAiodLtCoUBISAhCQkIMERYREdUTLkhERPQEyl/lVf5qr+f9Ki8mEyKiJ8CrvPTjkxaJiEg2npnQc4NLzRPVHf5l0XODS80T1R0OcxERkWw8M6FnDoeziOof/+LomcPhLKL6x2EuIiKSjcmEiIhk4zAXEZEBPO/PP2EyISIygOf9zngOcxERkWw8M6GnEi//JTIu/Gukp1Jll/8CvASYqCEwmRAR1aHnZWKeyYSIqA49LxPzTCZk1Dg3QvR04F8pGTUujULPqmdt+IvJhIioATxrw19MJmQUOJxF9HTjXy8ZBQ5nET3djO4O+B07dsDT0xO9evXC+PHjce7cuYYOiWpBZd0ELVpY6Xw1amQGlXWThg6NiOqAUZ2Z7N69G8HBwXj33Xfh6OiIL774AlOnTsXevXvRtm3bhg6P9KhqeErfmcaVEC+9k45EVOppnZg3mmQihMD69evx5ptvYvbs2QCAgQMHwsvLC9u2bcOyZcsaOMLnQ2XJoaBIi8aNzPS2eZLhqaomHYno6Z2YN5pk8uuvv+L27dsYOnSoVNaoUSO4u7vjyJEjDRjZs+lJzyjSw0czCRA1IGM/YzGaZJKeng4AaN++vU5527ZtcfPmTWi1WpiZ6f/P2FhU9gFdH7/suj6jIKKGZexnLCZCCNHQQQDAf/7zHyxatAhHjx5FixYtpPJvvvkGy5Ytw5kzZ6BSqRowQiIiqozRXM1VltNMTEz0bq+snIiIGp7RJBMrq9KxwLy8PJ3yvLw8mJmZQalUNkRYRERUA0aTTMrmSm7duqVTfuvWLdjZ2TVAREREVFNGk0zs7Ozw0ksvISEhQSorKirCwYMH4erq2oCRERFRdYzmai4TExNMnz4dISEhaNq0Kfr06YPt27fj/v378PPza+jwiIioCkZzNVeZuLg4fP7557h//z66deuGpUuXQq1WN3RYRERUBaNLJkRE9PQxmjmTunD16lW88847UKvVcHd3R2xsLKrKnevXr4eDg4Per/J35sfFxemtc+DAgXqPGQD++9//6o1n+/btUp2cnBwEBgbCxcUF/fv3R1BQEDQaw93qVJu4Hzx4gBUrVsDDwwNqtRrjx49HcnKyTh1D9vWTLiJak/d0+vRpeHt7w8nJCZ6enti5c+cTx2XImM+ePYtJkyahX79+GDRoEJYsWYLs7GydOq+++mqF/nRxcWmwmGfOnKn3d1z+yk5j6uehQ4dW+jmxYcMGqV5d93N5iYmJNRrBqdNjWjyjsrOzxcCBA8U777wjDh48KDZu3Ci6desmPvvss0rb/P777+LcuXM6X7t27RIODg5i06ZNUr3FixeLCRMmVKibk5NT7zELIcS6devEiBEjKsSTlZUl1Zk0aZLw8PAQ+/fvF/Hx8WLAgAHC399fVrxy4i4pKRGTJk0SL7/8sti1a5c4cuSIWLBggejatas4e/asVM9QfR0fHy+6du0q1q9fLw4ePCimTp0q1Gq1uHnzZq3f0y+//CKcnJzE/PnzxaFDh8SqVauEvb29+O67754oNkPF/MsvvwhHR0cxY8YMcfDgQfHtt9+KYcOGiddee00UFhYKIYT4888/Rffu3UVMTIxOf/70008NErMQQgwZMkR88MEHFX7HWq1Wel/G1M8XL16sEOvcuXNF7969RVpamhCi7vu5vDNnzgi1Wi169+5dZb26Pqaf2WQSGRkpnJ2dRX5+vlS2du1a4ezsLP1hVae4uFi88cYbwsfHR5SUlEjlr732mvj444+NJuZZs2aJ+fPnV7o9OTlZ2Nvbix9//FEqO378uLC3txc///xzg8R9/vx5YW9vL44fPy6VabVaMWbMGDF37lypzBB9XVJSIjw8PMT7778vlRUWFoqhQ4eKkJCQWr+nJUuWiFGjRukcGwEBAWLMmDGy4q1tzCtWrBBDhw7V6fOyfj548KAQQohLly4Je3t78csvv8iO0RAx5+TkCHt7e3Ho0KFK92ts/fy4CxcuiO7du4udO3dKZXXZz2X+/PNPERsbK3r06CH69+9fbTKp62P6mR3mOn78OFxdXdGkyf8/P2P48OF48OABfvrppxrt45tvvkFqairef/996Q784uJipKWlwcHBwWhiTk1NrTKe5ORkNG/eHE5OTlKZi4sLVCqVQRbRrE3cpqamePPNN9GnTx+dsvbt2yMjIwOA4fq6NouI1uQ9HT9+HO7u7jqrMwwfPhxXr15FZmZmvcfcuXNnTJkyBY0aNZLKOnbsCABSn6ampqJx48Z1cu9WbWJOTU0FgCp/x8bWz49btWoVHB0dMXbsWKmsLvu5zOHDhxEbG4slS5bAx8en2vp1fUw/s8kkPT1d76KRZduq8+eff2LDhg0YN24cunTpIpVfv34dRUVFOHLkCDw8PNCjRw+MHz8e58+fb5CYNRoNbt++jUuXLuGVV15Bjx498Oqrr+LQoUNSnRs3bqBdu3Y67UxNTdG6desa9UVdxN2zZ0+EhITA0tJS572cOnVK+gA0VF/XZBHRJ31P+fn5+OOPP2QdY4aOeeLEiZg4caJOWVJSEoD/Tyqpqalo2rQpFixYgD59+qBv374Gmz+rTcypqamwsLDAunXr4OLiAicnJ8ydOxdZWVkAYJT9XF5CQgLOnTuHpUuX6nwA12U/l3F0dERiYiJ8fX1rtNxUXR/TRnOfyZMoKirCzZs3K91ua2sLjUZTYQmWsp9r8gvdt28f7t69iylTpuiUl/0nlZ2djQ8++AAFBQX49NNP8c4772DXrl3o1KlTvcZ89epVCCGQkZGBwMBAmJmZ4X/+538wc+ZMbNmyBQMGDEBeXp7e5WiUSmW1fVEffV1m5cqV0Gg0mDx5MoDa9/XjymLQF2NJSQkePXpUYRHR6t5TVfss/5q1VZuYH/f777/jo48+Qs+ePTFgwAAApX2anZ0NBwcH+Pr64vLly/jkk0+QkZGBbdu21XvMqampKCwshFKpxIYNG3Dr1i2sW7cO77zzDvbs2WP0/bxt2zb07du3wuR3XfZzmZYtWz5R/bo+pp/KZJKZmYlRo0ZVuv0f//hHle1NTas/IduxYwcGDx5c4TR1wIABiI6OxqBBg6ThBBcXF3h6emLz5s0IDQ2t15g7d+6M2NhY9O3bVzro3dzc8Ne//hVRUVEYMGAAhBCVtq+uL+qjr4UQ+Oc//4lvv/0Wy5YtQ/fu3QHUvq/17R8w3CKipqam1e6zJu+7KnJj/v333+Hn54eSkhKsXbtWqh8QEIDCwkL07t0bANCvXz80b94cCxYswOnTp9GvX796jdnPzw+jR4+Wkl3//v3RqVMnvPnmm9i/f7+0+oUx9vP169dx8uRJREZGVthWl/1cFwxxTD+VyaRNmzbSf62ViY6O1rtoJIBq/6PLysrCjz/+iA8//LDCthYtWsDDw0OnTKVSQa1W48qVK/Ues7W1NYYMGaJTZmZmhoEDB2Lv3r1S27Jhg8f33aFDhypjquu+LiwsxJIlS/Ddd99h0aJFmDRpkrSttn39uPKLiNra2urEWNkioiqVqsr3VPa+KqtT9pq1VZuYy1y9ehXTp09HcXEx4uLidIY4yxJ1eS+//DIA4MqVK7I+5GoTc6dOnSqcYTo5OcHa2hqpqakYMWKEtI/yjKGfExMToVAoKhyjQN32c23V9TH9zM6Z2NnZSZOOZcoWkSwbP67MsWPHYGZmhmHDhlXYdurUKezbV/EBNQUFBXjhhRdkRFy7mC9duoRvvvmmynjs7OwqLKBZUlKC27dvV5tM6irushj9/f3x3//+FytWrIC/v7/OdkP1dW0WEa3uPSmVSrRo0ULvPgHI7tfaLnx6/vx5TJw4EWZmZvjyyy/RtWtXaVtxcTHi4+Nx6dIlnTYFBQUAIPv4rU3M+/btw6lTp3TKhBAoLCzECy+8YLT9DABHjhzB4MGDdeb9gLrv59qq62P6mU0mAwYMwPHjx5Gfny+VJSQkwMbGRucPTJ8LFy6gY8eOev+rTk5OxtKlS3X+08/KysLZs2fh7Oxc7zFfvnwZy5Yt0zlwCwoKcPjwYSkeV1dXZGVl4cKFC1KdlJQUaDQagyyiWdu+DggIwKlTp7BmzRq8/fbbFbYbqq9rs4hoTd6Tq6srDhw4oDNJm5CQAHt7ezRv3rzG8Rkq5lu3bmH69OmwtbXFv/71rwofhubm5li/fj3Wr1+vU/7DDz+gUaNG0pBMfcb8r3/9C6tWrUJJSYlUdujQIRQUFEj/vRtbPwOlCe/nn3/W22d13c+1VefH9JNc1/w0yczMFH379hUTJ04USUlJYtOmTRVu0MnNzRXnzp0Td+/e1Wnr4+Mj5syZo3e/d+7cEc7OzuKNN94QCQkJYv/+/WL06NHCw8NDaDSaeo9Zo9EIT09PMXz4cLFv3z6RkJAg3n77bdG/f3/x22+/CSFKr6X39vYWL7/8svj3v/8tdu/ebdCbFmsT9w8//CDs7e3FkiVLKtwAdvnyZSGEYft6+/btwsHBQURERIiDBw+KadOm6dyY9uuvv4pz58490Xu6fPmy6NGjh3j33XfFwYMHRWhoqEFvpnvSmGfOnCm6desm/v3vf1fo08zMTCGEEF999ZWwt7cXISEh4tixYyI6Olo4OjqK8PDwBon58OHDwsHBQSxcuFAcPXpUbN++XfTv31/n78/Y+lkIIW7duiXs7e3FgQMH9O6zrvv5cZ988kmF+0zq+5h+ZpOJEKU3E40fP1707NlTuLu7i5iYGJ3tJ06cEPb29mLXrl065SNHjhRBQUGV7vfatWvC399f9O/fX/Tp00fMmTNH3L59u8Fi/u2338SCBQuEq6urcHJyElOmTBGpqak67bKzs8W8efNE7969hbOzs/jHP/4hcnNzDRJzbeJeunSpsLe31/s1evRoqZ0h+3rz5s1iyJAholevXmL8+PE6d9qXxfMk70mI0g/D1157TfTs2VN4enpWOJbkqmnMhYWFonv37pX2afkPjF27dokxY8YIR0dH4eHhIaKioqS7zesz5jJJSUli3LhxwsnJSbi5uYnw8HDx6NEjnTrG0s9lym4GPX36dKX7rOt+Lk9fMqnvY5oLPRIRkWzP7JwJERHVHyYTIiKSjcmEiIhkYzIhIiLZmEyIiEg2JhMiIpKNyYSIiGRjMiEiItn+D09I7RY2HzsYAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pipe_train_df[\"uplift\"].hist(bins=50);\n", + "plt.title(\"Uplift Score Distribution\", fontsize=16);\n", + "plt.xticks(fontsize=16);\n", + "plt.yticks(fontsize=16);" + ] + }, + { + "cell_type": "markdown", + "id": "80873d8e", + "metadata": {}, + "source": [ + "**Checking Gain Curve with ECDF**" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "304ce7c2", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.405122Z", + "start_time": "2022-08-01T21:08:57.402884Z" + } + }, + "outputs": [], + "source": [ + "gain_curve = cumulative_gain_curve(\n", + " treatment = \"em1\",\n", + " outcome = target_column,\n", + " prediction = \"prediction_ecdf\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "875df4da", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.536943Z", + "start_time": "2022-08-01T21:08:57.406693Z" + } + }, + "outputs": [], + "source": [ + "pipeline_train_df = pipe_fcn(train_data)\n", + "pipeline_test_df = pipe_fcn(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "ed3ee7e7", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.747225Z", + "start_time": "2022-08-01T21:08:57.539511Z" + } + }, + "outputs": [], + "source": [ + "gain_curve_train = gain_curve(pipeline_train_df)\n", + "gain_curve_test = gain_curve(pipeline_test_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "af2707ed", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.939012Z", + "start_time": "2022-08-01T21:08:57.749300Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_cumulative_gain_curve(\n", + " train_gain = gain_curve_train,\n", + " test_gain = gain_curve_test,\n", + " random_gain = gain_curve_random\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ee410fb", + "metadata": {}, + "source": [ + "#### 4.3 Build T-learner Using Lightgbm with Isotonic Calibration" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ea34b176", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.944825Z", + "start_time": "2022-08-01T21:08:57.941394Z" + } + }, + "outputs": [], + "source": [ + "clf_learner = lgbm_classification_learner(\n", + " features = features,\n", + " target = target_column,\n", + " prediction_column = prediction_column\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "f328d84c", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.950805Z", + "start_time": "2022-08-01T21:08:57.947489Z" + } + }, + "outputs": [], + "source": [ + "calibrator = isotonic_calibration_learner(\n", + " target_column=target_column,\n", + " prediction_column=prediction_column,\n", + " output_column=\"calibration_prediction\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "9abd3945", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.955102Z", + "start_time": "2022-08-01T21:08:57.952772Z" + } + }, + "outputs": [], + "source": [ + "t_learner = causal_t_classification_learner(\n", + " treatment_col=treatment_column,\n", + " control_name=control_name,\n", + " prediction_column=\"calibration_prediction\",\n", + " learner=clf_learner,\n", + " learner_transformers=[calibrator]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "47630533", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.959571Z", + "start_time": "2022-08-01T21:08:57.957001Z" + } + }, + "outputs": [], + "source": [ + "cdf = ecdfer(\n", + " prediction_column=score_of_interest\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "9dfb55d3", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:57.964743Z", + "start_time": "2022-08-01T21:08:57.961573Z" + } + }, + "outputs": [], + "source": [ + "pipeline = build_pipeline(\n", + " *[t_learner, cdf]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "bb117302", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:58.188382Z", + "start_time": "2022-08-01T21:08:57.968255Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n", + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[LightGBM] [Info] Number of positive: 504, number of negative: 3808\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000469 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 963\n", + "[LightGBM] [Info] Number of data points in the train set: 4312, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.116883 -> initscore=-2.022283\n", + "[LightGBM] [Info] Start training from score -2.022283\n", + "[LightGBM] [Info] Number of positive: 1392, number of negative: 5088\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000172 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 898\n", + "[LightGBM] [Info] Number of data points in the train set: 6480, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.214815 -> initscore=-1.296143\n", + "[LightGBM] [Info] Start training from score -1.296143\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n", + "/Users/eduardo.souza/dev/nu/fklearn/venv/lib/python3.9/site-packages/lightgbm/basic.py:1491: UserWarning: 'silent' argument is deprecated and will be removed in a future release of LightGBM. Pass 'verbose' parameter via 'params' instead.\n", + " _log_warning(\"'silent' argument is deprecated and will be removed in a future release of LightGBM. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[LightGBM] [Info] Number of positive: 802, number of negative: 2568\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000512 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 958\n", + "[LightGBM] [Info] Number of data points in the train set: 3370, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.237982 -> initscore=-1.163774\n", + "[LightGBM] [Info] Start training from score -1.163774\n", + "[LightGBM] [Info] Number of positive: 309, number of negative: 529\n", + "[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000282 seconds.\n", + "You can set `force_col_wise=true` to remove the overhead.\n", + "[LightGBM] [Info] Total Bins 906\n", + "[LightGBM] [Info] Number of data points in the train set: 838, number of used features: 4\n", + "[LightGBM] [Info] [binary:BoostFromScore]: pavg=0.368735 -> initscore=-0.537647\n", + "[LightGBM] [Info] Start training from score -0.537647\n", + "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n" + ] + } + ], + "source": [ + "pipe_fcn, pipe_train_df, pipe_log = pipeline(\n", + " train_data\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "0a80c08c", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:58.205741Z", + "start_time": "2022-08-01T21:08:58.190857Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageincomeinsuranceinvestedem1em2em3convertedcontroltreatment_coltreatment_em3__calibration_prediction_on_treatmenttreatment_em3__uplifttreatment_em1__calibration_prediction_on_treatmenttreatment_em1__uplifttreatment_em2__calibration_prediction_on_treatmenttreatment_em2__upliftupliftsuggested_treatmentprediction_ecdf
044.15483.806155.2914294.8100100em30.3389830.2004290.8207550.6822010.0-0.1385540.682201treatment_em1813.133333
139.82737.9250069.407468.1510000em10.000000-0.0017270.000000-0.0017270.0-0.001727-0.001727control225.400000
249.02712.515707.085095.6500110em30.8833330.8833330.9825580.9825580.00.0000000.982558treatment_em1997.333333
339.72326.3715657.976345.2000001control0.0000000.0000000.1406250.1406250.00.0000000.140625treatment_em1606.133333
435.32787.2627074.4414114.8611000em10.0100500.0100500.0339510.0339510.00.0000000.033951treatment_em1518.400000
\n", + "
" + ], + "text/plain": [ + " age income insurance invested em1 em2 em3 converted control \\\n", + "0 44.1 5483.80 6155.29 14294.81 0 0 1 0 0 \n", + "1 39.8 2737.92 50069.40 7468.15 1 0 0 0 0 \n", + "2 49.0 2712.51 5707.08 5095.65 0 0 1 1 0 \n", + "3 39.7 2326.37 15657.97 6345.20 0 0 0 0 1 \n", + "4 35.3 2787.26 27074.44 14114.86 1 1 0 0 0 \n", + "\n", + " treatment_col treatment_em3__calibration_prediction_on_treatment \\\n", + "0 em3 0.338983 \n", + "1 em1 0.000000 \n", + "2 em3 0.883333 \n", + "3 control 0.000000 \n", + "4 em1 0.010050 \n", + "\n", + " treatment_em3__uplift treatment_em1__calibration_prediction_on_treatment \\\n", + "0 0.200429 0.820755 \n", + "1 -0.001727 0.000000 \n", + "2 0.883333 0.982558 \n", + "3 0.000000 0.140625 \n", + "4 0.010050 0.033951 \n", + "\n", + " treatment_em1__uplift treatment_em2__calibration_prediction_on_treatment \\\n", + "0 0.682201 0.0 \n", + "1 -0.001727 0.0 \n", + "2 0.982558 0.0 \n", + "3 0.140625 0.0 \n", + "4 0.033951 0.0 \n", + "\n", + " treatment_em2__uplift uplift suggested_treatment prediction_ecdf \n", + "0 -0.138554 0.682201 treatment_em1 813.133333 \n", + "1 -0.001727 -0.001727 control 225.400000 \n", + "2 0.000000 0.982558 treatment_em1 997.333333 \n", + "3 0.000000 0.140625 treatment_em1 606.133333 \n", + "4 0.000000 0.033951 treatment_em1 518.400000 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipe_train_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "65693eaa", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:58.442712Z", + "start_time": "2022-08-01T21:08:58.208095Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pipe_train_df[\"treatment_em1__calibration_prediction_on_treatment\"].hist(bins=10);\n", + "plt.title(\"Uplift with Calibrated LightGBM Distribution\", fontsize=16);\n", + "plt.xticks(fontsize=16);\n", + "plt.yticks(fontsize=16);" + ] + }, + { + "cell_type": "markdown", + "id": "bcf7861e", + "metadata": {}, + "source": [ + "**Checking Gain Curve with ECDF**" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "08cfa1e4", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:58.613042Z", + "start_time": "2022-08-01T21:08:58.610279Z" + } + }, + "outputs": [], + "source": [ + "gain_curve = cumulative_gain_curve(\n", + " treatment = \"em1\",\n", + " outcome = target_column,\n", + " prediction = \"prediction_ecdf\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "e996c832", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:58.755011Z", + "start_time": "2022-08-01T21:08:58.614934Z" + } + }, + "outputs": [], + "source": [ + "pipeline_train_df = pipe_fcn(train_data)\n", + "pipeline_test_df = pipe_fcn(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "159c3e84", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:58.968608Z", + "start_time": "2022-08-01T21:08:58.757109Z" + } + }, + "outputs": [], + "source": [ + "gain_curve_train = gain_curve(pipeline_train_df)\n", + "gain_curve_test = gain_curve(pipeline_test_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "d4dc9022", + "metadata": { + "ExecuteTime": { + "end_time": "2022-08-01T21:08:59.164538Z", + "start_time": "2022-08-01T21:08:58.970696Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_cumulative_gain_curve(\n", + " train_gain = gain_curve_train,\n", + " test_gain = gain_curve_test,\n", + " random_gain = gain_curve_random\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.12 ('venv': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + }, + "vscode": { + "interpreter": { + "hash": "7992107b5676fcc2947e8c872ad2cde6c7066279bc6e7ee23218548d8b4682e3" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/fklearn/causal/cate_learning/meta_learners.py b/src/fklearn/causal/cate_learning/meta_learners.py index 73719dd7..039afde7 100644 --- a/src/fklearn/causal/cate_learning/meta_learners.py +++ b/src/fklearn/causal/cate_learning/meta_learners.py @@ -1,6 +1,6 @@ import copy import inspect -from typing import Callable, List, Tuple +from typing import Callable, Dict, List, Tuple import numpy as np import pandas as pd @@ -185,32 +185,24 @@ def causal_s_classification_learner( of a new sample for both scenarios, i.e., with T = 0 and T = 1. The CATE τ is defined as τ(xi) = M(X=xi, T=1) - M(X=xi, T=0), being M a Machine Learning Model. - References: [1] https://matheusfacure.github.io/python-causality-handbook/21-Meta-Learners.html [2] https://causalml.readthedocs.io/en/latest/methodology.html - Parameters ---------- - df : pd.DataFrame A Pandas' DataFrame with features and target columns. The model will be trained to predict the target column from the features. - treatment_col: str The name of the column in `df` which contains the names of the treatments or control to which each data sample was subjected. - control_name: str The name of the control group. - prediction_column : str The name of the column with the predictions from the provided learner. - learner: Callable A fklearn classification learner function. - learner_transformers: list A list of fklearn transformer functions to be applied after the learner and before estimating the CATE. This parameter may be useful, for example, to estimate the CATE with calibrated classifiers. @@ -264,3 +256,194 @@ def p(new_df: pd.DataFrame) -> pd.DataFrame: causal_s_classification_learner.__doc__ += learner_return_docstring( "Causal S-Learner Classifier" ) + + +def _simulate_t_learner_treatment_effect( + df: pd.DataFrame, + learners: dict, + treatments: list, + control_name: str, + prediction_column: str, +) -> pd.DataFrame: + control_fcn = learners[control_name] + control_conversion_probability = control_fcn(df)[prediction_column].values + + scored_df = df.copy() + + uplift_cols = [] + for treatment_name in treatments: + treatment_fcn = learners[treatment_name] + treatment_conversion_probability = treatment_fcn(df)[prediction_column].values + + scored_df[ + f"treatment_{treatment_name}__{prediction_column}_on_treatment" + ] = treatment_conversion_probability + + uplift_cols.append(f"treatment_{treatment_name}__uplift") + scored_df[uplift_cols[-1]] = ( + treatment_conversion_probability - control_conversion_probability + ) + + scored_df["uplift"] = scored_df[uplift_cols].max(axis=1).values + scored_df["suggested_treatment"] = np.where( + scored_df["uplift"].values <= 0, + control_name, + scored_df[uplift_cols].idxmax(axis=1).values, + ) + scored_df["suggested_treatment"] = ( + scored_df["suggested_treatment"] + .apply(lambda x: x.replace("__uplift", "")) + .values + ) + + return scored_df + + +def _get_model_fcn( + df: pd.DataFrame, + treatment_col: str, + treatment_name: str, + learner: Callable, +) -> Tuple[Callable, dict, dict]: + """ + Returns a function that predicts the target column from the features. + """ + + treatment_names = df[treatment_col].unique() + + if treatment_name not in treatment_names: + raise MissingTreatmentError() + + df = df.loc[df[treatment_col] == treatment_name].reset_index(drop=True).copy() + + return learner(df) + + +def _get_learners( + df: pd.DataFrame, + control_learner: Callable, + treatment_learner: Callable, + unique_treatments: List[str], + control_name: str, + treatment_col: str, +) -> Tuple[Dict[str, Callable], Dict[str, dict]]: + learners: Dict[str, Callable] = {} + logs: Dict[str, dict] = {} + + learner_fcn, _, learner_logs = _get_model_fcn( + df, treatment_col, control_name, control_learner + ) + learners[control_name] = learner_fcn + logs[control_name] = learner_logs + + for treatment_name in unique_treatments: + learner_fcn, _, learner_logs = _get_model_fcn( + df, treatment_col, treatment_name, treatment_learner + ) + learners[treatment_name] = learner_fcn + logs[treatment_name] = learner_logs + + return learners, logs + + +@curry +def causal_t_classification_learner( + df: pd.DataFrame, + treatment_col: str, + control_name: str, + prediction_column: str, + learner: LearnerFnType, + treatment_learner: LearnerFnType = None, + learner_transformers: List[LearnerFnType] = None, +) -> LearnerReturnType: + """ + Fits a Causal T-Learner classifier. The T-Learner is a meta-learner which learns the + Conditional Average Treatment Effect (CATE) through the use of one Machine Learning + model for each treatment and for the control group. Each model is fitted in a subset of + the data, according to the treatment: the CATE $\tau$ is defined as + $\tau(x_{i}) = M_{1}(X=x_{i}, T=1) - M_{0}(X=x_{i}, T=0)$, being $M_{1}$ a model fitted + with treatment data and $M_{0}$ a model fitted with control data. Notice that $M_{0}$ + and $M_{1}$ are traditional Machine Learning models such as a LightGBM Classifier and + that $x_{i}$ is the feature set of sample $i$. + + References: + [1] https://matheusfacure.github.io/python-causality-handbook/21-Meta-Learners.html + [2] https://causalml.readthedocs.io/en/latest/methodology.html + + Parameters + ---------- + + df : pd.DataFrame + A Pandas' DataFrame with features and target columns. + The model will be trained to predict the target column + from the features. + + treatment_col: str + The name of the column in `df` which contains the names of + the treatments and control to which each data sample was subjected. + + control_name: str + The name of the control group. + + prediction_column : str + The name of the column with the predictions from the provided learner. + + learner: LearnerFnType + A fklearn classification learner function. + + treatment_learner: LearnerFnType + An optional fklearn classification learner function. + + learner_transformers: List[LearnerFnType] + A list of fklearn transformer functions to be applied after the learner and before estimating the CATE. + This parameter may be useful, for example, to estimate the CATE with calibrated classifiers. + """ + + control_learner = copy.deepcopy(learner) + + if treatment_learner is None: + treatment_learner = copy.deepcopy(learner) + + # pipeline + if learner_transformers is not None: + learner_transformers = copy.deepcopy(learner_transformers) + control_learner_pipe = build_pipeline(*[control_learner] + learner_transformers) + + treatment_learner_pipe = build_pipeline( + *[treatment_learner] + learner_transformers + ) + else: + control_learner_pipe = copy.deepcopy(control_learner) + treatment_learner_pipe = copy.deepcopy(treatment_learner) + + # learners + unique_treatments = _get_unique_treatments(df, treatment_col, control_name) + + learners, learners_logs = _get_learners( + df=df, + control_learner=control_learner_pipe, + treatment_learner=treatment_learner_pipe, + unique_treatments=unique_treatments, + control_name=control_name, + treatment_col=treatment_col, + ) + + def p(new_df: pd.DataFrame) -> pd.DataFrame: + return _simulate_t_learner_treatment_effect( + new_df, + learners, + unique_treatments, + control_name, + prediction_column, + ) + + p.__doc__ = learner_pred_fn_docstring("causal_t_classification_learner") + + log = {"causal_t_classification_learner": {**learners_logs}} + + return p, p(df), log + + +causal_t_classification_learner.__doc__ = learner_return_docstring( + "Causal T-Learner Classifier" +) diff --git a/tests/causal/cate_learning/test_meta_learners.py b/tests/causal/cate_learning/test_meta_learners.py index 4d982623..dd7d297e 100644 --- a/tests/causal/cate_learning/test_meta_learners.py +++ b/tests/causal/cate_learning/test_meta_learners.py @@ -1,20 +1,45 @@ -from unittest.mock import create_autospec, patch +from typing import Callable +from unittest.mock import MagicMock, call, create_autospec, patch import numpy as np import pandas as pd import pytest +from pandas import DataFrame +from pandas.testing import assert_frame_equal + from fklearn.causal.cate_learning.meta_learners import ( TREATMENT_FEATURE, _append_treatment_feature, _create_treatment_flag, - _filter_by_treatment, _fit_by_treatment, _get_unique_treatments, - _predict_by_treatment_flag, _simulate_treatment_effect, - causal_s_classification_learner) + _filter_by_treatment, _fit_by_treatment, _get_learners, _get_model_fcn, + _get_unique_treatments, _predict_by_treatment_flag, + _simulate_t_learner_treatment_effect, _simulate_treatment_effect, + causal_s_classification_learner, causal_t_classification_learner) from fklearn.exceptions.exceptions import (MissingControlError, MissingTreatmentError, MultipleTreatmentsError) from fklearn.training.classification import logistic_classification_learner from fklearn.types import LearnerFnType -from pandas import DataFrame -from pandas.testing import assert_frame_equal + + +@pytest.fixture +def base_input_df(): + return pd.DataFrame( + { + "x1": [1.3, 1.0, 1.8, -0.1, 0.0, 1.0, 2.2, 0.4, -5.0], + "x2": [10, 4, 15, 6, 5, 12, 14, 5, 12], + "treatment": [ + "A", + "B", + "A", + "A", + "B", + "control", + "control", + "B", + "control", + ], + "target": [1, 1, 1, 0, 0, 1, 0, 0, 1], + } + ) def test__append_treatment_feature(): @@ -191,26 +216,7 @@ def test__create_treatment_flag(): assert_frame_equal(results, expected) -def test__fit_by_treatment(): - df = pd.DataFrame( - { - "x1": [1.3, 1.0, 1.8, -0.1, 0.0, 1.0, 2.2, 0.4, -5.0], - "x2": [10, 4, 15, 6, 5, 12, 14, 5, 12], - "treatment": [ - "A", - "B", - "A", - "A", - "B", - "control", - "control", - "B", - "control", - ], - "target": [1, 1, 1, 0, 0, 1, 0, 0, 1], - } - ) - +def test__fit_by_treatment(base_input_df): learner_binary = logistic_classification_learner( features=["x1", "x2", TREATMENT_FEATURE], target="target", @@ -220,7 +226,7 @@ def test__fit_by_treatment(): treatments = ["A", "B"] learners, logs = _fit_by_treatment( - df, + base_input_df, learner=learner_binary, treatment_col="treatment", control_name="control", @@ -352,27 +358,8 @@ def test_causal_s_classification_learner( mock_get_unique_treatments, mock_fit_by_treatment, mock_simulate_treatment_effect, + base_input_df, ): - - df = pd.DataFrame( - { - "x1": [1.3, 1.0, 1.8, -0.1, 0.0, 1.0, 2.2, 0.4, -5.0], - "x2": [10, 4, 15, 6, 5, 12, 14, 5, 12], - "treatment": [ - "A", - "B", - "A", - "A", - "B", - "control", - "control", - "B", - "control", - ], - "target": [1, 1, 1, 0, 0, 1, 0, 0, 1], - } - ) - mock_model = create_autospec(logistic_classification_learner) mock_fit_by_treatment.side_effect = [ # treatment = A @@ -382,7 +369,7 @@ def test_causal_s_classification_learner( ] causal_s_classification_learner( - df, + base_input_df, treatment_col="treatment", control_name="control", prediction_column="prediction", @@ -394,3 +381,186 @@ def test_causal_s_classification_learner( mock_get_unique_treatments.assert_called() mock_fit_by_treatment.assert_called() mock_simulate_treatment_effect.assert_called() + + +def test_simulate_t_learner_treatment_effect(): + df = pd.DataFrame( + { + "x1": [1.3, 1.0, 1.8, -0.1], + "x2": [10, 4, 15, 6], + "treatment": ["A", "B", "A", "control"], + "target": [0, 0, 0, 1], + } + ) + + treatments = ["A", "B"] + control_name = "control" + prediction_column = "prediction" + + control_learner = MagicMock() + control_learner.side_effect = lambda _: pd.DataFrame({"prediction": [1, 2, 3, 4]}) + + treatment_learner = MagicMock() + treatment_learner.side_effect = lambda _: pd.DataFrame({"prediction": [3, 2, 4, 4]}) + + learners = { + "control": control_learner, + "A": treatment_learner, + "B": treatment_learner, + } + + result = _simulate_t_learner_treatment_effect( + df, + learners, + treatments, + control_name, + prediction_column, + ) + + print(result.suggested_treatment) + + expected = pd.DataFrame( + { + "x1": [1.3, 1.0, 1.8, -0.1], + "x2": [10, 4, 15, 6], + "treatment": ["A", "B", "A", "control"], + "target": [0, 0, 0, 1], + "treatment_A__prediction_on_treatment": [3, 2, 4, 4], + "treatment_A__uplift": [2, 0, 1, 0], + "treatment_B__prediction_on_treatment": [3, 2, 4, 4], + "treatment_B__uplift": [2, 0, 1, 0], + "uplift": [2, 0, 1, 0], + "suggested_treatment": ["treatment_A", "control", "treatment_A", "control"], + } + ) + + assert isinstance(result, pd.DataFrame) + assert_frame_equal(result, expected) + + +def test_get_model_fcn(base_input_df): + """ + Test if the fn is filtering the data + Test if the learner is called with the filtered data + """ + + fake_prediction_column = [0.1, 0.2, 0.3] + df_expected = pd.DataFrame( + { + "x1": [1.3, 1.8, -0.1], + "x2": [10, 15, 6], + "treatment": [ + "A", + "A", + "A", + ], + "target": [1, 1, 0], + "prediction": fake_prediction_column, + } + ) + + def mock_learner(df): + df["prediction"] = fake_prediction_column + + return (lambda x: x, df, dict()) + + learner = MagicMock() + learner.side_effect = mock_learner + + mock_fcn, mock_p_df, mock_logs = _get_model_fcn( + base_input_df, "treatment", "A", learner + ) + + assert isinstance(mock_fcn, Callable) + assert_frame_equal(mock_p_df, df_expected) + assert isinstance(mock_logs, dict) + + +def test_get_model_fcn_exception(base_input_df): + """ + Test if the fn is raising an exception when treatment name + is not in treatment list. + """ + + fake_prediction_column = [0.1, 0.2, 0.3] + + def mock_learner(df): + df["prediction"] = fake_prediction_column + + return (lambda x: x, df, dict()) + + learner = MagicMock() + learner.side_effect = mock_learner + + with pytest.raises(Exception) as e: + _ = _get_model_fcn(base_input_df, "treatment", "C", learner) + + assert e.type == MissingTreatmentError + + +@patch("fklearn.causal.cate_learning.meta_learners._get_model_fcn") +def test_get_learners(mock_get_model_fcn): + """ + Test if it is receiving a list of treatments and is returning a dict + of learners. + """ + unique_treatments = ["treatment_a", "treatment_b", "treatment_c"] + + mock_get_model_fcn.side_effect = [ + ("mocked_control_fcn", None, None), + ("mocked_treatment_fcn_filtering_treatment_a", None, None), + ("mocked_treatment_fcn_filtering_treatment_b", None, None), + ("mocked_treatment_fcn_filtering_treatment_c", None, None), + ] + + learners, logs = _get_learners( + df="mocked_df", + unique_treatments=unique_treatments, + treatment_col="treatment", + control_name="control", + control_learner="mocked_control_fcn", + treatment_learner="mocked_treatment_fcn", + ) + + assert learners["control"] == "mocked_control_fcn" + assert learners["treatment_a"] == "mocked_treatment_fcn_filtering_treatment_a" + assert learners["treatment_b"] == "mocked_treatment_fcn_filtering_treatment_b" + assert learners["treatment_c"] == "mocked_treatment_fcn_filtering_treatment_c" + assert isinstance(learners, dict) + assert isinstance(logs, dict) + + calls = [ + call("mocked_df", "treatment", "control", "mocked_control_fcn"), + call("mocked_df", "treatment", "treatment_a", "mocked_treatment_fcn"), + call("mocked_df", "treatment", "treatment_b", "mocked_treatment_fcn"), + call("mocked_df", "treatment", "treatment_c", "mocked_treatment_fcn"), + ] + + mock_get_model_fcn.assert_has_calls(calls) + + +@patch( + "fklearn.causal.cate_learning.meta_learners._simulate_t_learner_treatment_effect" +) +@patch("fklearn.causal.cate_learning.meta_learners._get_learners") +@patch("fklearn.causal.cate_learning.meta_learners._get_unique_treatments") +def test_causal_t_classification_learner( + mock_get_unique_treatments, + mock_get_learners, + mock_simulate_t_learner_treatment_effect, + base_input_df, +): + mock_get_learners.side_effect = [([], dict())] + mock_model = create_autospec(logistic_classification_learner) + + causal_t_classification_learner( + df=base_input_df, + treatment_col="treatment", + control_name="control", + prediction_column="prediction", + learner=mock_model, + ) + + mock_get_unique_treatments.assert_called() + mock_get_learners.assert_called() + mock_simulate_t_learner_treatment_effect.assert_called()