{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dW9C26GZCIJc"
   },
   "source": [
    "# The overview of the basic approaches to solving the Uplift Modeling problem\n",
    "\n",
    "<br>\n",
    "<center>\n",
    "    <a href=\"https://colab.research.google.com/github/maks-sh/scikit-uplift/blob/master/notebooks/RetailHero_EN.ipynb\">\n",
    "        <img src=\"https://colab.research.google.com/assets/colab-badge.svg\">\n",
    "    </a>\n",
    "    <br>\n",
    "    <b><a href=\"https://github.com/maks-sh/scikit-uplift/\">SCIKIT-UPLIFT REPO</a> | </b>\n",
    "    <b><a href=\"https://scikit-uplift.readthedocs.io/en/latest/\">SCIKIT-UPLIFT DOCS</a> | </b>\n",
    "    <b><a href=\"https://scikit-uplift.readthedocs.io/en/latest/user_guide/index.html\">USER GUIDE</a></b>\n",
    "    <br>\n",
    "    <b><a href=\"https://nbviewer.jupyter.org/github/maks-sh/scikit-uplift/blob/master/notebooks/RetailHero.ipynb\">RUSSIAN VERSION</a></b>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9Mz7V_YaCIKC"
   },
   "source": [
    "## Content\n",
    "\n",
    "* [Introduction](#Introduction)\n",
    "* [1. Single model approaches](#1.-Single-model-approaches)\n",
    "    * [1.1 Single model](#1.1-Single-model-with-treatment-as-feature)\n",
    "    * [1.2 Class Transformation](#1.2-Class-Transformation)\n",
    "* [2. Approaches with two models](#2.-Approaches-with-two-models)\n",
    "    * [2.1 Two independent models](#2.1-Two-independent-models)\n",
    "    * [2.2 Two dependent models](#2.2-Two-dependent-models)\n",
    "* [Conclusion](#Conclusion)\n",
    "\n",
    "## Introduction\n",
    "\n",
    "Before proceeding to the discussion of uplift modeling, let's imagine some situation:\n",
    "\n",
    "A customer comes to you with a certain problem: it is necessary to advertise a popular product using the sms.\n",
    "You know that the product is quite popular, and it is often installed by the customers without communication, that the usual binary classification will find the same customers, and the cost of communication is critical for us...\n",
    "\n",
    "And then you begin to understand that the product is already popular, that the product is often installed by customers  without communication, that the usual binary classification will find many such customers, and the cost of communication is critical for us...\n",
    "\n",
    "Historically, according to the impact of communication, marketers divide all customers into 4 categories:\n",
    "\n",
    "<p align=\"center\">\n",
    "  <img src=\"https://raw.githubusercontent.com/maks-sh/scikit-uplift/master/docs/_static/images/user_guide/ug_clients_types.jpg\" alt=\"Customer types\" width='40%'/>\n",
    "</p>\n",
    "\n",
    "- **`Do-Not-Disturbs`** *(a.k.a. Sleeping-dogs)* have a strong negative response to a marketing communication. They are going to purchase if *NOT* treated and will *NOT* purchase *IF* treated. It is not only a wasted marketing budget but also a negative impact. For instance, customers targeted could result in rejecting current products or services. In terms of math: $W_i = 1, Y_i = 0$ or $W_i = 0, Y_i = 1$.\n",
    "- **`Lost Causes`** will *NOT* purchase the product *NO MATTER* they are contacted or not. The marketing budget in this case is also wasted because it has no effect. In terms of math: $W_i = 1, Y_i = 0$ or $W_i = 0, Y_i = 0$.\n",
    "- **`Sure Things`** will purchase *ANYWAY* no matter they are contacted or not. There is no motivation to spend the budget because it also has no effect. In terms of math: $W_i = 1, Y_i = 1$ or $W_i = 0, Y_i = 1$.\n",
    "- **`Persuadables`** will always respond *POSITIVE* to the marketing communication. They is going to purchase *ONLY* if contacted (or sometimes they purchase *MORE* or *EARLIER* only if contacted). This customer's type should be the only target for the marketing campaign. In terms of math: $W_i = 0, Y_i = 0$ or $W_i = 1, Y_i = 1$.\n",
    "\n",
    "\n",
    "Because we can't communicate and not communicate with the customer at the same time, we will never be able to observe exactly which type a particular customer belongs to.\n",
    "\n",
    "Depends on the product characteristics and the customer base structure some types may be absent. In addition, a customer response depends heavily on various characteristics of the campaign, such as a communication channel or a type and a size of the marketing offer. To maximize profit, these parameters should be selected.\n",
    "\n",
    "Thus, when predicting uplift score and selecting a segment by the highest score, we are trying to find the only one type: **persuadables**.\n",
    "\n",
    "Thus, in this task, we don’t want to predict the probability of performing a target action, but to focus the advertising budget on the customers who will perform the target action only when we interact. In other words, we want to evaluate two conditional probabilities separately for each client:\n",
    "\n",
    "\n",
    "* Performing a targeted action when we influence the client. \n",
    "    We will refer such clients to the **test group (aka treatment)**: $P^T = P(Y=1 | W = 1)$,\n",
    "* Performing a targeted action without affecting the client. \n",
    "    We will refer such clients to the **control group (aka control)**: $P^C = P(Y=1 | W = 0)$,\n",
    "\n",
    "where $Y$ is the binary flag for executing the target action, and $W$ is the binary flag for communication (in English literature, _treatment_)\n",
    "\n",
    "The very same cause-and-effect effect is called **uplift** and is estimated as the difference between these two probabilities:\n",
    "\n",
    "$$ uplift = P^T - P^C = P(Y = 1 | W = 1) - P(Y = 1 | W = 0) $$\n",
    "\n",
    "Predicting uplift is a cause-and-effect inference task. The point is that you need to evaluate the difference between two events that are mutually exclusive for a particular client (either we interact with a person, or not; you can't perform two of these actions at the same time). This is why additional requirements for source data are required for building uplift models.\n",
    "\n",
    "To get a training sample for the uplift simulation, you need to conduct an experiment: \n",
    "1. Randomly split a representative part of the client base into a test and control group\n",
    "2. Communicate with the test group\n",
    "\n",
    "The data obtained as part of the design of such a pilot will allow us to build an uplift forecasting model in the future. It is also worth noting that the experiment should be as similar as possible to the campaign, which will be launched later on a larger scale. The only difference between the experiment and the campaign should be the fact that during the pilot, we choose random clients for interaction, and during the campaign - based on the predicted value of the Uplift. If the campaign that is eventually launched differs significantly from the experiment that is used to collect data about the performance of targeted actions by clients, then the model that is built may be less reliable and accurate.\n",
    "\n",
    "So, the approaches to predicting uplift are aimed at assessing the net effect of marketing campaigns on customers.\n",
    "\n",
    "All classical approaches to uplift modeling can be divided into two classes:\n",
    "1. Approaches with the same model\n",
    "2. Approaches using two models\n",
    "\n",
    "Let's download [RetailHero.ai contest data](https://ods.ai/competitions/x5-retailhero-uplift-modeling/data):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "# install uplift library scikit-uplift and other libraries \n",
    "!{sys.executable} -m pip install scikit-uplift catboost pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklift.datasets import fetch_x5\n",
    "import pandas as pd\n",
    "\n",
    "pd.set_option('display.max_columns', None)\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "403bc6dad1064a009b067f9489eafcad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0.00/1.18M [00:00<?, ?iB/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f0ccb86098cb48859fcd27ee8e17fcb4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0.00/7.64M [00:00<?, ?iB/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2b3def7cbda14e099bf231bb47304e7d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0.00/670M [00:00<?, ?iB/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "dict_keys(['data', 'target', 'treatment', 'DESCR', 'feature_names', 'target_name', 'treatment_name'])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = fetch_x5()\n",
    "dataset.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset type: <class 'sklearn.utils.Bunch'>\n",
      "\n",
      "Dataset features shape: (400162, 5)\n",
      "Dataset features shape: (200039, 1)\n",
      "Dataset target shape: (200039,)\n",
      "Dataset treatment shape: (200039,)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Dataset type: {type(dataset)}\\n\")\n",
    "print(f\"Dataset features shape: {dataset.data['clients'].shape}\")\n",
    "print(f\"Dataset features shape: {dataset.data['train'].shape}\")\n",
    "print(f\"Dataset target shape: {dataset.target.shape}\")\n",
    "print(f\"Dataset treatment shape: {dataset.treatment.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "76e99aut_1nH"
   },
   "source": [
    "Read more about dataset <a href=\"https://www.uplift-modeling.com/en/latest/api/datasets/fetch_x5.html\">in the api docs</a>.  \n",
    "\n",
    "Now let's preprocess it a bit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:39.095040Z",
     "start_time": "2020-05-30T22:29:36.013799Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "wojgYP76CIKH"
   },
   "outputs": [],
   "source": [
    "# extract data\n",
    "df_clients = dataset.data['clients'].set_index(\"client_id\")\n",
    "df_train = pd.concat([dataset.data['train'], dataset.treatment , dataset.target], axis=1).set_index(\"client_id\")\n",
    "indices_test = pd.Index(set(df_clients.index) - set(df_train.index))\n",
    "\n",
    "# extracting features\n",
    "df_features = df_clients.copy()\n",
    "df_features['first_issue_time'] = \\\n",
    "    (pd.to_datetime(df_features['first_issue_date'])\n",
    "     - pd.Timestamp('1970-01-01')) // pd.Timedelta('1s')\n",
    "df_features['first_redeem_time'] = \\\n",
    "    (pd.to_datetime(df_features['first_redeem_date'])\n",
    "     - pd.Timestamp('1970-01-01')) // pd.Timedelta('1s')\n",
    "df_features['issue_redeem_delay'] = df_features['first_redeem_time'] \\\n",
    "    - df_features['first_issue_time']\n",
    "df_features = df_features.drop(['first_issue_date', 'first_redeem_date'], axis=1)\n",
    "\n",
    "indices_learn, indices_valid = train_test_split(df_train.index, test_size=0.3, random_state=123)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LB42pR6iCIK9"
   },
   "source": [
    "For convenience, we will declare some variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:40.203839Z",
     "start_time": "2020-05-30T22:29:39.097441Z"
    },
    "colab": {},
    "colab_type": "code",
    "id": "_HyKmGQ_CILw"
   },
   "outputs": [],
   "source": [
    "X_train = df_features.loc[indices_learn, :]\n",
    "y_train = df_train.loc[indices_learn, 'target']\n",
    "treat_train = df_train.loc[indices_learn, 'treatment_flg']\n",
    "\n",
    "X_val = df_features.loc[indices_valid, :]\n",
    "y_val = df_train.loc[indices_valid, 'target']\n",
    "treat_val =  df_train.loc[indices_valid, 'treatment_flg']\n",
    "\n",
    "X_train_full = df_features.loc[df_train.index, :]\n",
    "y_train_full = df_train.loc[:, 'target']\n",
    "treat_train_full = df_train.loc[:, 'treatment_flg']\n",
    "\n",
    "X_test = df_features.loc[indices_test, :]\n",
    "\n",
    "cat_features = ['gender']\n",
    "\n",
    "models_results = {\n",
    "    'approach': [],\n",
    "    'uplift@30%': []\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "olRc5k9iCIMP"
   },
   "source": [
    "## 1. Single model approaches\n",
    "\n",
    "### 1.1 Single model with treatment as feature\n",
    "\n",
    "The most intuitive and simple uplift modeling technique. A training set consists of two groups: treatment samples and control samples. There is also a binary treatment flag added as a feature to the training set. After the model is trained, at the scoring time it is going to be applied twice:\n",
    "with the treatment flag equals `1` and with the treatment flag equals `0`. Subtracting these model's outcomes for each test sample, we will get an estimate of the uplift.\n",
    "\n",
    "<p align=\"center\">\n",
    "  <img src=\"https://raw.githubusercontent.com/maks-sh/scikit-uplift/master/docs/_static/images/SoloModel.png\" alt=\"Solo model with treatment as a feature\"/>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:42.146943Z",
     "start_time": "2020-05-30T22:29:40.207117Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 444
    },
    "colab_type": "code",
    "id": "Aq5-jjbeCIMa",
    "outputId": "83b9f995-a4ec-4c7b-933c-e60521956ab6"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# installation instructions: https://github.com/maks-sh/scikit-uplift\n",
    "# link to the documentation: https://scikit-uplift.readthedocs.io/en/latest/\n",
    "from sklift.metrics import uplift_at_k\n",
    "from sklift.viz import plot_uplift_preds\n",
    "from sklift.models import SoloModel\n",
    "\n",
    "# sklift supports all models, \n",
    "# that satisfy scikit-learn convention\n",
    "# for example, let's use catboost\n",
    "from catboost import CatBoostClassifier\n",
    "\n",
    "\n",
    "sm = SoloModel(CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True))\n",
    "sm = sm.fit(X_train, y_train, treat_train, estimator_fit_params={'cat_features': cat_features})\n",
    "\n",
    "uplift_sm = sm.predict(X_val)\n",
    "\n",
    "sm_score = uplift_at_k(y_true=y_val, uplift=uplift_sm, treatment=treat_val, strategy='by_group', k=0.3)\n",
    "\n",
    "models_results['approach'].append('SoloModel')\n",
    "models_results['uplift@30%'].append(sm_score)\n",
    "\n",
    "# get conditional probabilities (predictions) of performing the target action \n",
    "# during interaction for each object\n",
    "sm_trmnt_preds = sm.trmnt_preds_\n",
    "# And conditional probabilities (predictions) of performing the target action \n",
    "# without interaction for each object\n",
    "sm_ctrl_preds = sm.ctrl_preds_\n",
    "\n",
    "# draw the probability (predictions) distributions and their difference (uplift)\n",
    "plot_uplift_preds(trmnt_preds=sm_trmnt_preds, ctrl_preds=sm_ctrl_preds);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:42.172080Z",
     "start_time": "2020-05-30T22:29:42.150138Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 235
    },
    "colab_type": "code",
    "id": "VH0YzW0JCIM0",
    "outputId": "f9e2ae2f-904d-4210-9271-fb74d97e2402"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature_name</th>\n",
       "      <th>feature_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>first_redeem_time</td>\n",
       "      <td>65.214393</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>issue_redeem_delay</td>\n",
       "      <td>12.564364</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>age</td>\n",
       "      <td>7.891613</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>first_issue_time</td>\n",
       "      <td>7.262806</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>treatment</td>\n",
       "      <td>4.362077</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>gender</td>\n",
       "      <td>2.704747</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         feature_name  feature_score\n",
       "0   first_redeem_time      65.214393\n",
       "1  issue_redeem_delay      12.564364\n",
       "2                 age       7.891613\n",
       "3    first_issue_time       7.262806\n",
       "4           treatment       4.362077\n",
       "5              gender       2.704747"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also access the trained model with the same ease.\n",
    "# For example, to build the importance of features:\n",
    "sm_fi = pd.DataFrame({\n",
    "    'feature_name': sm.estimator.feature_names_,\n",
    "    'feature_score': sm.estimator.feature_importances_\n",
    "}).sort_values('feature_score', ascending=False).reset_index(drop=True)\n",
    "\n",
    "sm_fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Fi_ypKsrCINU"
   },
   "source": [
    "### 1.2 Class Transformation\n",
    "\n",
    "Simple yet powerful and mathematically proven uplift modeling method, presented in 2012.\n",
    "The main idea is to predict a slightly changed target $Z_i$:\n",
    "\n",
    "$$\n",
    "Z_i = Y_i \\cdot W_i + (1 - Y_i) \\cdot (1 - W_i),\n",
    "$$\n",
    "\n",
    "where \n",
    "\n",
    "* $Z_i$ - new target variable of the $i$ client; \n",
    "* $Y_i$ - target variable of the $i$ client;\n",
    "* $W_i$ - flag for communication of the $i$ client;  \n",
    "\n",
    "\n",
    "In other words, the new target equals 1 if a response in the treatment group is as good as a response in the control group and equals 0 otherwise:\n",
    "\n",
    "$$\n",
    "Z_i = \\begin{cases}\n",
    "    1, & \\mbox{if } W_i = 1 \\mbox{ and } Y_i = 1 \\\\\n",
    "    1, & \\mbox{if } W_i = 0 \\mbox{ and } Y_i = 0 \\\\\n",
    "    0, & \\mbox{otherwise}\n",
    "   \\end{cases}\n",
    "$$\n",
    "\n",
    "Let's go deeper and estimate the conditional probability of the target variable:\n",
    "\n",
    "$$ \n",
    "P(Z=1|X = x) = \\\\\n",
    "= P(Z=1|X = x, W = 1) \\cdot P(W = 1|X = x) + \\\\\n",
    "+ P(Z=1|X = x, W = 0) \\cdot P(W = 0|X = x) = \\\\\n",
    "= P(Y=1|X = x, W = 1) \\cdot P(W = 1|X = x) + \\\\\n",
    "+ P(Y=0|X = x, W = 0) \\cdot P(W = 0|X = x).\n",
    "$$\n",
    "\n",
    "We assume that $ W $ is independent of $X = x$ by design.\n",
    "Thus we have: $P(W | X = x) = P(W)$ and\n",
    "\n",
    "$$\n",
    "P(Z=1|X = x) = \\\\\n",
    "= P^T(Y=1|X = x) \\cdot P(W = 1) + \\\\\n",
    "+ P^C(Y=0|X = x) \\cdot P(W = 0)\n",
    "$$\n",
    "\n",
    "Also, we assume that $P(W = 1) = P(W = 0) = \\frac{1}{2}$, which means that during the experiment the control and the treatment groups were divided in equal proportions. Then we get the following:\n",
    "\n",
    "$$\n",
    "P(Z=1|X = x) = \\\\\n",
    "= P^T(Y=1|X = x) \\cdot \\frac{1}{2} + P^C(Y=0|X = x) \\cdot \\frac{1}{2} \\Rightarrow \\\\\n",
    "2 \\cdot P(Z=1|X = x) = \\\\\n",
    "= P^T(Y=1|X = x) + P^C(Y=0|X = x) = \\\\\n",
    "= P^T(Y=1|X = x) + 1 - P^C(Y=1|X = x) \\Rightarrow \\\\\n",
    "\\Rightarrow P^T(Y=1|X = x) - P^C(Y=1|X = x) = \\\\\n",
    " = uplift = 2 \\cdot P(Z=1|X = x) - 1\n",
    "$$\n",
    "\n",
    "Thus, by doubling the estimate of the new target $Z$ and subtracting one we will get an estimation of the uplift:\n",
    "\n",
    "$$\n",
    "uplift = 2 \\cdot P(Z=1) - 1\n",
    "$$\n",
    "\n",
    "This approach is based on the assumption: $P(W = 1) = P(W = 0) = \\frac{1}{2}$,  That is the reason that it has to be used only in cases where the number of treated customers (communication) is equal to the number of control customers (no communication)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:43.218019Z",
     "start_time": "2020-05-30T22:29:42.175286Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 71
    },
    "colab_type": "code",
    "id": "j8ZobWF-CINc",
    "outputId": "16ccac52-b9f5-4d55-a05c-1d3270819f91",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/zj/l29x8njj1yncqvpwgkycthvw0000gp/T/ipykernel_74119/2974985256.py:5: UserWarning: It is recommended to use this approach on treatment balanced data. Current sample size is unbalanced.\n",
      "  ct = ct.fit(X_train, y_train, treat_train, estimator_fit_params={'cat_features': cat_features})\n"
     ]
    }
   ],
   "source": [
    "from sklift.models import ClassTransformation\n",
    "\n",
    "\n",
    "ct = ClassTransformation(CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True))\n",
    "ct = ct.fit(X_train, y_train, treat_train, estimator_fit_params={'cat_features': cat_features})\n",
    "\n",
    "uplift_ct = ct.predict(X_val)\n",
    "\n",
    "ct_score = uplift_at_k(y_true=y_val, uplift=uplift_ct, treatment=treat_val, strategy='by_group', k=0.3)\n",
    "\n",
    "models_results['approach'].append('ClassTransformation')\n",
    "models_results['uplift@30%'].append(ct_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jaCZSMxyCIOV"
   },
   "source": [
    "## 2. Approaches with two models\n",
    "\n",
    "The two-model approach can be found in almost any uplift modeling work and is often used as a baseline. However, using two models can lead to some unpleasant consequences: if you use fundamentally different models for training, or if the nature of the test and control group data is very different, then the scores returned by the models will not be comparable. As a result, the calculation of the uplift will not be completely correct. To avoid this effect, you need to calibrate the models so that their scores can be interpolated as probabilities. The calibration of model probabilities is described perfectly in [scikit-learn documentation](https://scikit-learn.org/stable/modules/calibration.html).\n",
    "\n",
    "### 2.1 Two independent models\n",
    "\n",
    "The main idea is to estimate the conditional probabilities of the treatment and control groups separately.\n",
    "\n",
    "1. Train the first model using the treatment set.\n",
    "2. Train the second model using the control set.\n",
    "3. Inference: subtract the control model scores from the treatment model scores.\n",
    "\n",
    "<p align= \"center\">\n",
    "  <img src=\"https://raw.githubusercontent.com/maks-sh/scikit-uplift/master/docs/_static/images/TwoModels_vanila.png\" alt=\"Two Models vanila\"/>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:44.967862Z",
     "start_time": "2020-05-30T22:29:43.220363Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 444
    },
    "colab_type": "code",
    "id": "ydBCIN_XCIOb",
    "outputId": "b6f2a15a-cdbc-42ba-c013-95cae220c946"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklift.models import TwoModels\n",
    "\n",
    "\n",
    "tm = TwoModels(\n",
    "    estimator_trmnt=CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True), \n",
    "    estimator_ctrl=CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True), \n",
    "    method='vanilla'\n",
    ")\n",
    "tm = tm.fit(\n",
    "    X_train, y_train, treat_train,\n",
    "    estimator_trmnt_fit_params={'cat_features': cat_features}, \n",
    "    estimator_ctrl_fit_params={'cat_features': cat_features}\n",
    ")\n",
    "\n",
    "uplift_tm = tm.predict(X_val)\n",
    "\n",
    "tm_score = uplift_at_k(y_true=y_val, uplift=uplift_tm, treatment=treat_val, strategy='by_group', k=0.3)\n",
    "\n",
    "models_results['approach'].append('TwoModels')\n",
    "models_results['uplift@30%'].append(tm_score)\n",
    "\n",
    "plot_uplift_preds(trmnt_preds=tm.trmnt_preds_, ctrl_preds=tm.ctrl_preds_);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9a8BCVaYCIPH"
   },
   "source": [
    "### 2.2 Two dependent models\n",
    "\n",
    "The dependent data representation approach is based on the classifier chain method originally developed\n",
    "for multi-class classification problems. The idea is that if there are $L$ different classifiers, each of which solves the problem of binary classification and in the learning process,\n",
    "each subsequent classifier uses the predictions of the previous ones as additional features.\n",
    "The authors of this method proposed to use the same idea to solve the problem of uplift modeling in two stages.\n",
    "\n",
    "At the beginning we train the classifier based on the control data:\n",
    "\n",
    "$$\n",
    "P^C = P(Y=1| X, W = 0),\n",
    "$$\n",
    "\n",
    "Next, we estimate the $P_C$ predictions and use them as a feature for the second classifier.\n",
    "It effectively reflects a dependency between treatment and control datasets:\n",
    "\n",
    "$$\n",
    "P^T =  P(Y=1| X, P_C(X), W = 1)\n",
    "$$\n",
    "\n",
    "To get the uplift for each observation, calculate the difference:\n",
    "\n",
    "$$\n",
    "uplift(x_i) = P^T(x_i, P_C(x_i)) - P^C(x_i)\n",
    "$$\n",
    "\n",
    "Intuitively, the second classifier learns the difference between the expected probability in the treatment and the control sets which is the uplift.\n",
    "\n",
    "<p align= \"center\">\n",
    "  <img src=\"https://raw.githubusercontent.com/maks-sh/scikit-uplift/master/docs/_static/images/TwoModels_ddr_control.png\", alt=\"Two dependent models\"/>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:46.835046Z",
     "start_time": "2020-05-30T22:29:44.970479Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 444
    },
    "colab_type": "code",
    "id": "vBHTDpX-CIPR",
    "outputId": "32d97144-dd91-49d3-e020-026fdfb0460f"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tm_ctrl = TwoModels(\n",
    "    estimator_trmnt=CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True), \n",
    "    estimator_ctrl=CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True), \n",
    "    method='ddr_control'\n",
    ")\n",
    "tm_ctrl = tm_ctrl.fit(\n",
    "    X_train, y_train, treat_train,\n",
    "    estimator_trmnt_fit_params={'cat_features': cat_features}, \n",
    "    estimator_ctrl_fit_params={'cat_features': cat_features}\n",
    ")\n",
    "\n",
    "uplift_tm_ctrl = tm_ctrl.predict(X_val)\n",
    "\n",
    "tm_ctrl_score = uplift_at_k(y_true=y_val, uplift=uplift_tm_ctrl, treatment=treat_val, strategy='by_group', k=0.3)\n",
    "\n",
    "models_results['approach'].append('TwoModels_ddr_control')\n",
    "models_results['uplift@30%'].append(tm_ctrl_score)\n",
    "\n",
    "plot_uplift_preds(trmnt_preds=tm_ctrl.trmnt_preds_, ctrl_preds=tm_ctrl.ctrl_preds_);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gsHLrueoCIP2"
   },
   "source": [
    "Similarly, you can first train the $P^T$ classifier, and then use its predictions as a feature for the $P^C$ classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:48.818365Z",
     "start_time": "2020-05-30T22:29:46.838201Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 444
    },
    "colab_type": "code",
    "id": "gwcyMZogCIP4",
    "outputId": "91583f7c-c48d-40f2-c375-0a8d7cf69d9c"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x504 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tm_trmnt = TwoModels(\n",
    "    estimator_trmnt=CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True), \n",
    "    estimator_ctrl=CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True), \n",
    "    method='ddr_treatment'\n",
    ")\n",
    "tm_trmnt = tm_trmnt.fit(\n",
    "    X_train, y_train, treat_train,\n",
    "    estimator_trmnt_fit_params={'cat_features': cat_features}, \n",
    "    estimator_ctrl_fit_params={'cat_features': cat_features}\n",
    ")\n",
    "\n",
    "uplift_tm_trmnt = tm_trmnt.predict(X_val)\n",
    "\n",
    "tm_trmnt_score = uplift_at_k(y_true=y_val, uplift=uplift_tm_trmnt, treatment=treat_val, strategy='by_group', k=0.3)\n",
    "\n",
    "models_results['approach'].append('TwoModels_ddr_treatment')\n",
    "models_results['uplift@30%'].append(tm_trmnt_score)\n",
    "\n",
    "plot_uplift_preds(trmnt_preds=tm_trmnt.trmnt_preds_, ctrl_preds=tm_trmnt.ctrl_preds_);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BLd9GH1WCIQT"
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "Let's consider which method performed best in this task and use it to speed up the test sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:48.837333Z",
     "start_time": "2020-05-30T22:29:48.821645Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "x6pYalimCIQW",
    "outputId": "7910ceb8-e15e-4d4b-ae2d-4e0ab0ac7737"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>approach</th>\n",
       "      <th>uplift@30%</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ClassTransformation</td>\n",
       "      <td>0.061775</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>TwoModels</td>\n",
       "      <td>0.051637</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>TwoModels_ddr_control</td>\n",
       "      <td>0.047793</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>SoloModel</td>\n",
       "      <td>0.041614</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>TwoModels_ddr_treatment</td>\n",
       "      <td>0.033752</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  approach  uplift@30%\n",
       "1      ClassTransformation    0.061775\n",
       "2                TwoModels    0.051637\n",
       "3    TwoModels_ddr_control    0.047793\n",
       "0                SoloModel    0.041614\n",
       "4  TwoModels_ddr_treatment    0.033752"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(data=models_results).sort_values('uplift@30%', ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L55TyGbWCIQ0"
   },
   "source": [
    "From the table above you can see that the current task suits best for the approach to the transformation of the target line. Let's train the model on the entire sample and predict the test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:51.343823Z",
     "start_time": "2020-05-30T22:29:48.840611Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 156
    },
    "colab_type": "code",
    "id": "WnVKI1qZCIQ3",
    "outputId": "b1efb1d4-1f83-4c53-d3c8-84060d7a2d11"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/zj/l29x8njj1yncqvpwgkycthvw0000gp/T/ipykernel_74119/678512574.py:2: UserWarning: It is recommended to use this approach on treatment balanced data. Current sample size is unbalanced.\n",
      "  ct_full = ct_full.fit(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ",uplift\r\n",
      "55fc931967,0.04837912929135735\r\n",
      "fb5445ac57,-0.013699691220019017\r\n",
      "a98e84d4bb,0.02776242838414622\r\n",
      "c389a8165c,0.01015125634618097\r\n"
     ]
    }
   ],
   "source": [
    "ct_full = ClassTransformation(CatBoostClassifier(iterations=20, thread_count=2, random_state=42, silent=True))\n",
    "ct_full = ct_full.fit(\n",
    "    X_train_full, \n",
    "    y_train_full, \n",
    "    treat_train_full, \n",
    "    estimator_fit_params={'cat_features': cat_features}\n",
    ")\n",
    "\n",
    "X_test.loc[:, 'uplift'] = ct_full.predict(X_test.values)\n",
    "\n",
    "sub = X_test[['uplift']].to_csv('sub1.csv')\n",
    "\n",
    "!head -n 5 sub1.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-05-30T22:29:51.401905Z",
     "start_time": "2020-05-30T22:29:51.346944Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature_name</th>\n",
       "      <th>feature_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>first_redeem_time</td>\n",
       "      <td>86.662273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>age</td>\n",
       "      <td>5.582358</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>issue_redeem_delay</td>\n",
       "      <td>3.467160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>first_issue_time</td>\n",
       "      <td>2.755578</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>gender</td>\n",
       "      <td>1.532631</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         feature_name  feature_score\n",
       "0   first_redeem_time      86.662273\n",
       "1                 age       5.582358\n",
       "2  issue_redeem_delay       3.467160\n",
       "3    first_issue_time       2.755578\n",
       "4              gender       1.532631"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ct_full = pd.DataFrame({\n",
    "    'feature_name': ct_full.estimator.feature_names_,\n",
    "    'feature_score': ct_full.estimator.feature_importances_\n",
    "}).sort_values('feature_score', ascending=False).reset_index(drop=True)\n",
    "\n",
    "ct_full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5wHQNSHdCIRj"
   },
   "source": [
    "This way we got acquainted with uplift modeling and considered the main basic approaches to its construction. What's next? Then you can plunge them into the intelligence analysis of data, generate some new features, select the models and their hyperparameters and learn new approaches and libraries.\n",
    "\n",
    "**Thank you for reading to the end.**\n",
    "\n",
    "**I will be pleased if you support the project with an star on [github](https://github.com/maks-sh/scikit-uplift/) or tell your friends about it.**"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "RetailHero_EN.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}