what is confusion matrix?

the confusion matrix in machine learning is the easiest way to measure the performance of a classification problem where the output can be of two or more type of classes. it is nothing but a table with two dimensions viz. "actual" and "predicted" and furthermore, both the dimensions have "true positives (tp)", "true negatives (tn)", "false positives (fp)", "false negatives (fn)" as shown below −

take an example of classifying emails as "spam" and "not spam" for a better understanding. here a spam email is labeled as "positive" and a legitimate (not spam) email is labeled as negative.

explanation of the terms associated with confusion matrix are as follows −

true positives (tp) − it is the case when both actual class & predicted class of data point is 1. the classification model correctly predicts the positive class label for data sample. for example, a "spam" email is classified as "spam".
true negatives (tn) − it is the case when both actual class & predicted class of data point is 0. the model correctly predicts the negative class label for data sample. for example, a "not spam" email is classified as "not spam".
false positives (fp) − it is the case when actual class of data point is 0 & predicted class of data point is 1. the model incorrectly predicts the positive class label for data sample. for example, a "not spam" email is misclassified as "spam". it is known as a type i error.
false negatives (fn) − it is the case when actual class of data point is 1 & predicted class of data point is 0. the model incorrectly predicts the negative class label for data sample. for example, a "spam" email is misclassified as "not spam". it is also known as type ii error.

we use the confusion matrix to find correct and incorrect classifications −

correct classification − tp and tn are correctly classified data points.
incorrect classification − fp and fn are incorrectly classified data points.

we can use the confusion matrix to calculate different classification metrics such as accuracy, precision, recall, etc. but before discussing these metrics, let's take understand how to create a confusion matrix with the help of a practical exmaple.

confusion matrix practical example

let's take a practical example for a classifications of emails as "spam" or "not spam". here we are representing class for a spam email as positive (1) and a not spam email as negative (0). so emails are classified either −

spam (1) − positive class lebel
not spam (0) − negative class lebel

the actual and predicted classes/ categories are as follows −

actual classification	0	1	0	1	1	0	0	1	1	1
predicted classification	0	1	0	1	0	1	0	0	1	1

so with the above results, let's find out that a particular classification falls under tp, tn, fp or fn. look at the below table −

actual classification	0	1	0	1	1	0	0	1	1	1
predicted classification	0	1	0	1	0	1	0	0	1	1
result	tn	tp	tn	tp	fn	fp	tn	fn	tp	tp

in above table, when we compare actual classification set to the predicted classification, we observe that there are four different types of outcomes. first, true positive (1,1), i.e. the actual classification is positive and predicted classification is also postive. this means the classifier has identified postive sample correctly. second, false negative (1,0), i.e., the actual classification is positive and predicted classification in negative. the classifier has identified positive sample as negative.

third, false positive, (0,1), i.e., the actual classification is negative and predicted classification is postive. the negative sample is incorrectly identified as positive. fourth, true negative (0,0), i.e., the actual and predicted classifications are negative. the negative sample is correctly identified by model as negative.

let's find the total number of samples in each categories.

tp (true positive): 4
fn (false negative): 2
fp (false positive): 1
tn (true negative): 3

let's now create confusion matrix as following −

		actual class
		positive (1)	negative (0)
predicted class	positive (1)	4 (tp)	1 (fp)
predicted class	negative (0)	2 (fn)	3 (tn)

so far we have created the confusion matrix for above problem. let's infer some meaning from the above matrix −

amongst 10 emails, four "spam" emails are correctly classified as "spam" (tp).
amongst 10 emails, two "spam" emails are incorrectly classified as "not spam" (fn).
amongst 10 emails, one "not spam" email is incorrectly classified as "spam" (fp).
amongst 1o emails, three "not spam" emails are correctly classified as "not spam" (tn).
so amongst 10 emails, seven emails are correctly classified (tp & tn)and three emails are incorrectly classified (fp & fn).

classificaiton metrics based on confusion matrix

we can define many classificaiton performance metrics using the confusion matrix. we will consider the above practical example and calculate the metrics using the values in that example. some of them are as follows −

accuracy
precision
recall or sensitivity
specificity
f1 score
type i error rate
type ii error rate

accuracy

accuracy is most common metrics to evaluate a classification model. it is ratio of total correction predictions and all predictions made. mathematically we can use the following formula to calculate accurcy −

$$\mathrm{accuracy = \frac{tp + tn}{tp + fp + fn + tn}}$$

let's calculate the accuracy −

$$\mathrm{accuracy = \frac{4 + 3}{4 + 1 + 2 + 3}= \frac{7}{10} = 0.7}$$

hence the model's classification accuracy is 70%.

precision

precision measures the proportion of true positive instances out of all predicted positive instances. it is calculated as ratio of the number of true positive instances and the sum of true positive and false positive instances.

$$\mathrm{precision = \frac{tp}{tp + fp}}$$

let's calculate the precision −

$$\mathrm{precision = \frac{4}{4 + 1} = \frac{4}{5} = 0.8}$$

recall or sensitivity

recall (sensitivity) is defined as the number of positives classifications by the classifier. we can calculate it with the help of following formula

$$\mathrm{recall = \frac{tp}{tp + fn}}$$

let's calculate recall −

$$\mathrm{recall = \frac{4}{4 + 2} = \frac{4}{6} = 0.666}$$

specificity

specificity, in contrast to recall, is defined as the number of negatives returned by the classifier. we can calculate it with the help of following formula −

$$\mathrm{specificity = \frac{tn}{tn + fp}}$$

let's calculate the specificity −

$$\mathrm{specificity = \frac{3}{3 + 1} = \frac{3}{4} = 0.75}$$

f1 score

f1 score is a balanced measure that takes into account both precision and recall. it is the harmonic mean of precision and recall.

we can calculate f1 score with the help of following formula −

$$\mathrm{f1 \: score = 2 \times \frac{(precision \times recall)}{precision + recall}}$$

let's calculate f1 score −

$$\mathrm{f1 \: score = 2 \times \frac{(0.8 \times 0.667)}{0.8 + 0.667} = 0.727}$$

hence, f1 score is 0.727.

type i error rate

type i error occurs when the classifier predicts positive classification but it is actually negative class. the type i error rate is calculated as −

$$\mathrm{type \: i \: error \: rate = \frac{fp}{fp + tn}}$$

$$\mathrm{type \: i \: error \: rate = \frac{1}{1 + 3} = \frac{1}{4} = 0.25}$$

type ii error rate

type ii error occurs when the classifier predicts negative but it is actually positive class. the type ii error rate can be calculate as −

$$\mathrm{type \: ii \: error \: rate = \frac{fn}{fn + tp}}$$

$$\mathrm{type \: ii \: error \: rate = \frac{2}{2 + 4} = \frac{2}{6} = 0.333}$$

how to implement confusion matrix in python?

to implement the confusion matrix in python, we can use the confusion_matrix() function from the sklearn.metrics module of the scikit-learn library.

note: please note that the confusion_matrix() function returns a 2d array that correspondence to the following confusion matrix −

		predicted class
		negative (0)	positive (1)
actual class	negative (0)	true negative (tn)	false positive (fp)
actual class	positive (1)	false negative (fn)	true positive (tp)

here is an simple example of how to use the confusion_matrix() function −

from sklearn.metrics import confusion_matrix

# actual values
y_actual = [0, 1, 0, 1, 1, 0, 0, 1, 1, 1]

# predicted values
y_pred = [0, 1, 0, 1, 0, 1, 0, 0, 1, 1]

# confusion matrix
cm = confusion_matrix(y_actual, y_pred)
print(cm)

in this example, we have two arrays: y_actual contains the actual values of the target variable, and y_pred contains the predicted values of the target variable. we then call the confusion_matrix() function, passing in y_actual and y_pred as arguments. the function returns a 2d array that represents the confusion matrix.

the output of the code above will look like this −

[[3 1]
 [2 4]]

compare the above result with the confusion matrix we created above.

true negative (tn): 3
false positive (fp): 1
false negative (fn): 2
true positive (tp): 4

we can also visualize the confusion matrix using a heatmap. below is how we can do that using the heatmap() function from the seaborn library

import seaborn as sns

# plot confusion matrix as heatmap
sns.heatmap(cm, annot=true, cmap='summer')

this will produce a heatmap that shows the confusion matrix −

in this heatmap, the x-axis represents the predicted values, and the y-axis represents the actual values. the color of each square in the heatmap indicates the number of samples that fall into each category.

Save or share this article