03_promotional_offer_recommender.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "1963c485-808e-4e6b-96bd-c10c4033ae99",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "This solution accelerator notebook is available at https://github.com/databricks-industry-solutions/causal-incentive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "024797c4-a68e-482f-bd95-6e4847fc992b",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "## Cluster Configuration\n",
    "We recommend using a cluster with the following or similar specifications to run this solution accelerator:\n",
    "- Unity Catalog enabled cluster\n",
    "- Databricks Runtime 15.4 LTS ML or above\n",
    "- Single-node cluster: e.g. `m5d.2xlarge` on AWS or `Standard_D8ds_v5` on Azure Databricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "6a6554be-f60d-427a-b044-7672ed13bc5a",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "## Install Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "12ff48a2-6fc0-40a5-a867-686630c7bf9c",
     "showTitle": true,
     "tableResultSettingsMap": {},
     "title": "Install requirements"
    }
   },
   "outputs": [],
   "source": [
    "%pip install -r ./requirements.txt --quiet\n",
    "dbutils.library.restartPython()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "eb599ae6-4b84-4808-922b-458856a6fa1d",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    },
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "%run ./util/notebook-config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "3f9a1d4f-6247-4358-bf1a-f79d7f2e3e94",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "#### Individualized Promotional Offer Recommendations\n",
    "\n",
    "Armed with the models trained in the previous step,  we can develop a composite model that estimates the effects of each incentive on new companies based on their specific characteristics.  The model will select the promotional offer(s) with the highest effect on ```Revenue``` after accounting for the cost of the offer. In the following cell, we define this composite model using MLflow's custom python model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a03e256a-67a4-4e6a-9367-003f6624e916",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "class PersonalizedIncentiveRecommender(mlflow.pyfunc.PythonModel):\n",
    "    \"\"\"Custom wrapper for a personalized incentive recommender.\"\"\"\n",
    "\n",
    "    def __init__(self, models_dictionary, effect_modifiers):\n",
    "        self.models_dictionary = models_dictionary\n",
    "        self.effect_modifiers = effect_modifiers\n",
    "\n",
    "    def _estimate_isolated_effect(self, model_input):\n",
    "        \"\"\"Compute the constant marginal conditional average treatment effect \"\"\"\n",
    "        \"\"\"conditioned on the effect modifiers for each company.\"\"\"\n",
    "        return pd.DataFrame(\n",
    "            {\n",
    "                f\"{key} net effect\": np.hstack(\n",
    "                    model.const_marginal_effect(model_input[self.effect_modifiers])\n",
    "                )\n",
    "                for key, model in self.models_dictionary.items()\n",
    "            }\n",
    "        )\n",
    "\n",
    "    def _estimate_effect_with_interaction(self, estimated_effects):\n",
    "        \"\"\"Combine the estimated isolated effects of each treatment.\"\"\"\n",
    "        effects_interaction = (\n",
    "            \" and \".join(self.models_dictionary.keys()) + \" net effect\"\n",
    "        )\n",
    "        estimated_effects[effects_interaction] = estimated_effects.sum(axis=1, numeric_only=True)\n",
    "        return estimated_effects\n",
    "\n",
    "    def _cost_fn_interaction(self, data):\n",
    "        \"\"\"Calculate the cost of each treatment and the total cost.\"\"\"\n",
    "        t1_cost = data[[\"PC Count\"]].values * 100\n",
    "        t2_cost = np.ones((data.shape[0], 1)) * 7000\n",
    "        return np.hstack([t1_cost, t2_cost, t1_cost + t2_cost])\n",
    "\n",
    "    def _estimate_net_effects(self, estimated_effects, costs):\n",
    "        \"\"\"Subtract the cost of each treatment from each estimated isolated effect \"\"\"\n",
    "        \"\"\"and the total cost from the combined effect.\"\"\"\n",
    "        return estimated_effects - costs\n",
    "\n",
    "    def _get_recommended_incentive(self, net_effects):\n",
    "        \"\"\"Make an incentive recommendation with the max estimated net effect.\"\"\"\n",
    "        net_effects[\"recommended incentive\"] = net_effects.idxmax(axis=1).apply(\n",
    "            lambda x: x.replace(\" net effect\", \"\")\n",
    "        )\n",
    "        net_effects[\"recommended incentive net effect\"] = net_effects.max(axis=1, numeric_only=True)\n",
    "        return net_effects\n",
    "\n",
    "    def predict(self, context, model_input):\n",
    "        \"\"\"Given a dataset of new companies returns the personalized recommended \"\"\"\n",
    "        \"\"\"policy for each customer.\"\"\"\n",
    "        estimated_effects = self._estimate_isolated_effect(model_input)\n",
    "        estimated_effects = self._estimate_effect_with_interaction(estimated_effects)\n",
    "        costs = self._cost_fn_interaction(model_input)\n",
    "        net_effects = self._estimate_net_effects(estimated_effects, costs)\n",
    "        net_effects[\"no incentive net effect\"] = 0\n",
    "        net_effects = self._get_recommended_incentive(net_effects)\n",
    "        return model_input.join(net_effects)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "182d5be1-f0fb-417f-bd9c-e8cb8c75440c",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "###Registering in MLflow the Personalized Incentive Recommender model\n",
    "\n",
    "We will instantiate the composite model for personalized incentive recommendation. Note that we are passing on only two models for the treatment effect estimation: i.e. ```tech_support_total_effect_dowhy_model``` and ```discount_dowhy_model```, althought we were intially interested in measuring the effect of ```New Engagement Strategy``` as well. This is because we found in the previous notebook that this treatment has no effect on ```Revenue```.\n",
    "\n",
    "After we instantiate the model, we will log it in MLflow together with some other important information like model signature and dependencies. Eventually this model will get registered under the model name ```personalized_policy_recommender```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "e6204a2c-bc30-46da-9d5e-71adfbff6837",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "from mlflow.models.signature import infer_signature\n",
    "\n",
    "model_name = f\"{catalog}.{db}.personalized_policy_recommender\"\n",
    "\n",
    "with mlflow.start_run(run_name=f\"{model_name}_run\") as experiment_run:\n",
    "    #Instantiate a model \n",
    "    personalizedIncentiveRecommender = PersonalizedIncentiveRecommender(\n",
    "        models_dictionary={\n",
    "            \"tech support\": get_registered_wrapped_model_estimator(\n",
    "                model_name=f\"{catalog}.{db}.tech_support_total_effect_dowhy_model\"\n",
    "            ),\n",
    "            \"discount\": get_registered_wrapped_model_estimator(\n",
    "                model_name=f\"{catalog}.{db}.discount_dowhy_model\"\n",
    "            ),\n",
    "        },\n",
    "        effect_modifiers=[\"Size\", \"Global Flag\"],\n",
    "    )\n",
    "    #Log the model in MLflow\n",
    "    model_details = mlflow.pyfunc.log_model(\n",
    "        artifact_path=\"model\",\n",
    "        python_model=personalizedIncentiveRecommender,\n",
    "        registered_model_name=model_name,\n",
    "        signature=infer_signature(\n",
    "            input_df.drop([\"Tech Support\", \"Discount\", \"New Engagement Strategy\"], axis=1), \n",
    "            personalizedIncentiveRecommender.predict({}, input_df)\n",
    "        ),\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "47331bbd-1c8c-46fb-bbdf-2f3cef7adb21",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "###Loading model and Predicting the best incentive(s) per account\n",
    "\n",
    "We can see new columns are added to the DataFrame with the information estimated by the model:\n",
    "\n",
    "- ```recommended incentive```: incentive or combination of incentives that would result in the optimal return\n",
    "- ```recommended incentive net effect```:  Dollar effect on \"revenue\" of the recommended incentive(s) after substracting cost \n",
    "- ```discount net effect```: Dollar effect on ```Revenue``` of the ```Discount``` incentive\n",
    "- ```tech support net effect```: Dollar effect on ```Revenue``` of the ```tech support``` incentive\n",
    "- ```tech support + discount net effect```: Dollar effect on ```Revenue``` of providing both incentives\n",
    "- ```no incentive net effect```: Dollar effect on ```Revenue``` of providing no incentive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "5d7d00c3-2d48-4e32-ac93-f0dae8ca3781",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "#Load the model from MLflow\n",
    "loaded_model = mlflow.pyfunc.load_model(\n",
    "    f\"{model_details.model_uri}\"\n",
    ")\n",
    "final_df = loaded_model.predict(input_df)\n",
    "display(final_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "3af4d7d2-07e7-4694-b507-0e6ed8d5910e",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "###Comparing Policies\n",
    "\n",
    "We can see in the comparison how following the personalized recommender approach an average gain of ~5K per account is obtained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "566ab2e3-0d22-49ed-bec4-7bbf19cfa67e",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "final_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "9bd15800-17bb-4805-8a3c-82e8da057d31",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "all_policies_df = final_df.merge(input_df)\n",
    "\n",
    "##Adding the previous year \"no policy\" scenario\n",
    "all_policies_df[\"no policy\"] = (all_policies_df[\"Tech Support\"]*all_policies_df[\"tech support net effect\"]) + (all_policies_df[\"Discount\"]*all_policies_df[\"discount net effect\"])\n",
    "\n",
    "compare_policies_effects(all_policies_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "430ed66f-df52-4b3c-97f2-b482236f2433",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "#### Individualized Policy Recommendations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "6f5f2040-c2cf-4129-9b40-c26a30648ef9",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "We can take a step deeper and inspect the best treatment plan for each customer. This links to the exploratory data analysis that we performed in the first notebook (```00_intro```), where we found that there was no strategy for providing incentives to customers. We color code the customer based on the recommended best treatment types and that gives us boundaries along the values of ```PC Count``` and ```Size```. These boudaries are linear because we use linear models for the effect estimation using double machine learning. Had we assigned the treatments based on our model suggestion instead of at random, we could have maximized the return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "186e105c-e7e2-42b0-b528-9a624d7967c7",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# Plot the recommended policy of each customer\n",
    "plt.figure(figsize=(10, 7.5))\n",
    "plot_policy(final_df, final_df[\"recommended incentive\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a855e7b1-6cd4-4195-9be7-1effd6c7197a",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "This modeling technique (DML) lets us estimate the isolated effect of a given incentive while controlling for confounders. We can obtain an unbiased estimate for each treatment, which is something hard to achieve using traditional ML techniques.\n",
    "\n",
    "The recommender can be used to obtain the optimal incetive for new accounts given the accounts characteristics.  For example assuming the first of the rows in the \"input_df\" belong to a new account just onboarded, the sales team can obtain a recommednation of which incentives to offer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "bdc04774-3b77-467b-99ec-0584e33bff8d",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "new_account = input_df.head(1).drop([\"Tech Support\", \"Discount\", \"New Engagement Strategy\"], axis=1)\n",
    "new_account"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "b6d8268c-0a51-4e53-b0b1-45e5dcce9724",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "####Obtain Promotinal Offer(s) Recommedation for New Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "42ae946e-b195-4b3b-8f4f-d8c284afb6f6",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "incentive_recommended = loaded_model.predict(new_account)\n",
    "\n",
    "displayHTML(\n",
    "    f\"<H2>Recommended incentive(s) for new account:</h2><h2>- {incentive_recommended[['recommended incentive']].values[0][0].capitalize()}</H2>\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "e84f7dcb-5129-4df8-a62b-b8c2f7291678",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "MLflow allows leveraging the recommender in [batch processing](https://mlflow.org/docs/latest/python_api/mlflow.pyfunc.html#mlflow.pyfunc.spark_udf) or as a REST API via [Databricks model serving](https://docs.databricks.com/machine-learning/model-serving/index.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "d83c00ca-2833-4b9e-bd3e-106c2813c533",
     "showTitle": false,
     "tableResultSettingsMap": {},
     "title": ""
    }
   },
   "source": [
    "© 2023 Databricks, Inc. All rights reserved. The source in this notebook is provided subject to the Databricks License. All included or referenced third party libraries are subject to the licenses set forth below.\n",
    "\n",
    "| library                                | description             | license    | source                                              |\n",
    "|----------------------------------------|-------------------------|------------|-----------------------------------------------------|\n",
    "| dowhy   | Python library for causal inference that supports explicit modeling and testing of causal assumptions | MIT   | https://pypi.org/project/dowhy/          \n",
    "| econml   |  contains several methods for calculating Conditional Average Treatment Effects | MIT    | https://pypi.org/project/econml/  \n",
    "| causal-learn   | python package for causal discovery  | MIT    | https://pypi.org/project/causal-learn/"
   ]
  }
 ],
 "metadata": {
  "application/vnd.databricks.v1+notebook": {
   "computePreferences": null,
   "dashboards": [],
   "environmentMetadata": null,
   "language": "python",
   "notebookMetadata": {
    "mostRecentlyExecutedCommandWithImplicitDF": {
     "commandId": 1375557022084102,
     "dataframes": [
      "_sqldf"
     ]
    },
    "pythonIndentUnit": 2
   },
   "notebookName": "03_promotional_offer_recommender",
   "widgets": {}
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}