{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the Cost-Benefit Matrix Objective\n",
    "\n",
    "The Cost-Benefit Matrix (`CostBenefitMatrix`) objective is an objective that assigns costs to each of the quadrants of a confusion matrix to quantify the cost of being correct or incorrect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion Matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Confusion matrices](https://en.wikipedia.org/wiki/Confusion_matrix) are tables that summarize the number of correct and incorrectly-classified predictions, broken down by each class. They allow us to quickly understand the performance of a classification model and where the model gets \"confused\" when it is making predictions. For the binary classification problem, there are four possible combinations of prediction and actual target values possible:\n",
    "\n",
    "- true positives (correct positive assignments)\n",
    "- true negatives (correct negative assignments)\n",
    "- false positives (incorrect positive assignments)\n",
    "- false negatives (incorrect negative assignments)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of how to calculate a confusion matrix can be found [here](../user_guide/model_understanding.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cost-Benefit Matrix\n",
    "\n",
    "Although the confusion matrix is an incredibly useful visual for understanding our model, each prediction that is correctly or incorrectly classified is treated equally. For example, for detecting breast cancer, the confusion matrix  does not take into consideration that it could be much more costly to incorrectly classify a malignant tumor as benign than it is to incorrectly classify a benign tumor as malignant. This is where the cost-benefit matrix shines: it uses the cost of each of the four possible outcomes to weigh each outcome differently. By scoring using the cost-benefit matrix, we can measure the score of the model by a concrete unit that is more closely related to the goal of the model. In the below example, we will show how the cost-benefit matrix objective can be used, and how it can give us better real-world impact when compared to using other standard machine learning objectives."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Customer Churn Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data\n",
    "\n",
    "In this example, we will be using a customer churn data set taken from [Kaggle](https://www.kaggle.com/blastchar/telco-customer-churn?select=WA_Fn-UseC_-Telco-Customer-Churn.csv).\n",
    "\n",
    "\n",
    "This dataset includes records of over 7000 customers, and includes customer account information, demographic information, services they signed up for, and whether or not the customer \"churned\" or left within the last month. \n",
    "\n",
    "The target we want to predict is whether the customer churned (\"Yes\") or did not churn (\"No\"). In the dataset, approximately 73.5% of customers did not churn, and 26.5% did. We will refer to the customers who churned as the \"positive\" class and the customers who did not churn as the \"negative\" class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evalml.demos.churn import load_churn\n",
    "from evalml.preprocessing import split_data\n",
    "\n",
    "X, y = load_churn()\n",
    "X.ww.set_types(\n",
    "    {\"PaymentMethod\": \"Categorical\", \"Contract\": \"Categorical\"}\n",
    ")  # Update data types Woodwork did not correctly infer\n",
    "X_train, X_holdout, y_train, y_holdout = split_data(\n",
    "    X, y, problem_type=\"binary\", test_size=0.3, random_seed=0\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, let's say that correctly identifying customers who will churn (true positive case) will give us a net profit of \\\\$400, because it allows us to intervene, incentivize the customer to stay, and sign a new contract. Incorrectly classifying customers who were not going to churn as customers who will churn (false positive case) will cost \\\\$100 to represent the marketing and effort used to try to retain the user. Not identifying customers who will churn (false negative case) will cost us \\\\$200 to represent the lost in revenue from losing a customer. Finally, correctly identifying customers who will not churn (true negative case) will not cost us anything (\\\\$0), as nothing needs to be done for that customer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can represent these values in our `CostBenefitMatrix` objective, where a negative value represents a cost and a positive value represents a profit--note that this means that the greater the score, the more profit we will make."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evalml.objectives import CostBenefitMatrix\n",
    "\n",
    "cost_benefit_matrix = CostBenefitMatrix(\n",
    "    true_positive=400, true_negative=0, false_positive=-100, false_negative=-200\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### AutoML Search with Log Loss\n",
    "\n",
    "First, let us run AutoML search to train pipelines using the default objective for binary classification (log loss)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evalml import AutoMLSearch\n",
    "\n",
    "automl = AutoMLSearch(\n",
    "    X_train=X_train,\n",
    "    y_train=y_train,\n",
    "    problem_type=\"binary\",\n",
    "    objective=\"log loss binary\",\n",
    "    max_iterations=5,\n",
    "    verbose=True,\n",
    ")\n",
    "automl.search(interactive_plot=False)\n",
    "\n",
    "ll_pipeline = automl.best_pipeline\n",
    "ll_pipeline.score(X_holdout, y_holdout, [\"log loss binary\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we train our pipelines using log loss as our primary objective, we try to find pipelines that minimize log loss. However, our ultimate goal in training models is to find a model that gives us the most profit, so let's score our pipeline on the cost benefit matrix (using the costs outlined above) to determine the profit we would earn from the predictions made by this model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll_pipeline_score = ll_pipeline.score(X_holdout, y_holdout, [cost_benefit_matrix])\n",
    "print(ll_pipeline_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate total profit across all customers using pipeline optimized for Log Loss\n",
    "total_profit_ll = ll_pipeline_score[\"Cost Benefit Matrix\"] * len(X)\n",
    "print(total_profit_ll)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### AutoML Search with Cost-Benefit Matrix\n",
    "\n",
    "Let's try rerunning our AutoML search, but this time using the cost-benefit matrix as our primary objective to optimize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "automl = AutoMLSearch(\n",
    "    X_train=X_train,\n",
    "    y_train=y_train,\n",
    "    problem_type=\"binary\",\n",
    "    objective=cost_benefit_matrix,\n",
    "    max_iterations=5,\n",
    "    verbose=True,\n",
    ")\n",
    "automl.search(interactive_plot=False)\n",
    "\n",
    "cbm_pipeline = automl.best_pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, if we calculate the cost-benefit matrix score on our best pipeline, we see that with this pipeline optimized for our cost-benefit matrix objective, we are able to generate more profit per customer. Across our 7043 customers, we generate much more profit using this best pipeline! Custom objectives like `CostBenefitMatrix` are just one example of how using EvalML can help find pipelines that can perform better on real-world problems, rather than on arbitrary standard statistical metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbm_pipeline_score = cbm_pipeline.score(X_holdout, y_holdout, [cost_benefit_matrix])\n",
    "print(cbm_pipeline_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate total profit across all customers using pipeline optimized for CostBenefitMatrix\n",
    "total_profit_cbm = cbm_pipeline_score[\"Cost Benefit Matrix\"] * len(X)\n",
    "print(total_profit_cbm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate difference in profit made using both pipelines\n",
    "profit_diff = total_profit_cbm - total_profit_ll\n",
    "print(profit_diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can graph the confusion matrices for both pipelines to better understand why the pipeline trained using the cost-benefit matrix is able to correctly classify more samples than the pipeline trained with log loss: we were able to correctly predict more cases where the customer would have churned (true positive), allowing us to intervene and prevent those customers from leaving."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from evalml.model_understanding.metrics import graph_confusion_matrix\n",
    "\n",
    "# pipeline trained with log loss\n",
    "y_pred = ll_pipeline.predict(X_holdout)\n",
    "graph_confusion_matrix(y_holdout, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pipeline trained with cost-benefit matrix\n",
    "y_pred = cbm_pipeline.predict(X_holdout)\n",
    "graph_confusion_matrix(y_holdout, y_pred)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}