# Using the Cost-Benefit Matrix Objective#

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.

## Confusion Matrix#

Confusion matrices 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:

true positives (correct positive assignments)

true negatives (correct negative assignments)

false positives (incorrect positive assignments)

false negatives (incorrect negative assignments)

An example of how to calculate a confusion matrix can be found here.

## Cost-Benefit Matrix#

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.

## Customer Churn Example#

### Data#

In this example, we will be using a customer churn data set taken from Kaggle.

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.

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.

```
[1]:
```

```
from evalml.demos.churn import load_churn
from evalml.preprocessing import split_data
X, y = load_churn()
X.ww.set_types(
{"PaymentMethod": "Categorical", "Contract": "Categorical"}
) # Update data types Woodwork did not correctly infer
X_train, X_holdout, y_train, y_holdout = split_data(
X, y, problem_type="binary", test_size=0.3, random_seed=0
)
```

```
Number of Features
Categorical 16
Numeric 3
Number of training examples: 7043
Targets
No 73.46%
Yes 26.54%
Name: Churn, dtype: object
```

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.

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.

```
[2]:
```

```
from evalml.objectives import CostBenefitMatrix
cost_benefit_matrix = CostBenefitMatrix(
true_positive=400, true_negative=0, false_positive=-100, false_negative=-200
)
```

### AutoML Search with Log Loss#

First, let us run AutoML search to train pipelines using the default objective for binary classification (log loss).

```
[3]:
```

```
from evalml import AutoMLSearch
automl = AutoMLSearch(
X_train=X_train,
y_train=y_train,
problem_type="binary",
objective="log loss binary",
max_iterations=5,
verbose=True,
)
automl.search(interactive_plot=False)
ll_pipeline = automl.best_pipeline
ll_pipeline.score(X_holdout, y_holdout, ["log loss binary"])
```

```
AutoMLSearch will use mean CV score to rank pipelines.
*****************************
* Beginning pipeline search *
*****************************
Optimizing for Log Loss Binary.
Lower score is better.
Using SequentialEngine to train and score pipelines.
Searching up to 5 pipelines.
Allowed model families:
Evaluating Baseline Pipeline: Mode Baseline Binary Classification Pipeline
Mode Baseline Binary Classification Pipeline:
Starting cross validation
Finished cross validation - mean Log Loss Binary: 9.563
*****************************
* Evaluating Batch Number 1 *
*****************************
Logistic Regression Classifier w/ Label Encoder + Replace Nullable Types Transformer + Imputer + One Hot Encoder + Standard Scaler:
Starting cross validation
Finished cross validation - mean Log Loss Binary: 0.422
Random Forest Classifier w/ Label Encoder + Replace Nullable Types Transformer + Imputer + One Hot Encoder:
Starting cross validation
Finished cross validation - mean Log Loss Binary: 0.422
*****************************
* Evaluating Batch Number 2 *
*****************************
Logistic Regression Classifier w/ Label Encoder + Replace Nullable Types Transformer + Imputer + One Hot Encoder + Standard Scaler + RF Classifier Select From Model:
Starting cross validation
Finished cross validation - mean Log Loss Binary: 0.422
Random Forest Classifier w/ Label Encoder + Replace Nullable Types Transformer + Imputer + One Hot Encoder + RF Classifier Select From Model:
Starting cross validation
Finished cross validation - mean Log Loss Binary: 0.424
Search finished after 00:17
Best pipeline: Random Forest Classifier w/ Label Encoder + Replace Nullable Types Transformer + Imputer + One Hot Encoder
Best pipeline Log Loss Binary: 0.421573
```