Confusion Matrix

easyFREEModel EvaluationMachine Learning 1

Build a confusion matrix for binary classification results.

Given lists of true labels and predicted labels (each 0 or 1), compute the 2x2 confusion matrix:

$\begin{bmatrix} TN & FP \\ FN & TP \end{bmatrix}$

where:

TP (True Positive): predicted 1, actual 1
TN (True Negative): predicted 0, actual 0
FP (False Positive): predicted 1, actual 0
FN (False Negative): predicted 0, actual 1

Return the matrix as a 2D list [[TN, FP], [FN, TP]].

Example

Input

y_true = [1, 0, 1, 1, 0, 0]
y_pred = [1, 0, 0, 1, 0, 1]

Output

[[2, 1], [1, 2]]

Reasoning

Inputs: y_true holds the actual class of each of 6 examples and y_pred the model's guess; position $i$ pairs truth $y_i$ with prediction $\hat{y}_i$ . Here the pairs are $(1,1), (0,0), (1,0), (1,1), (0,0), (0,1)$ .
Classify each pair: truth 0 and prediction 0 is a true negative, which happens at positions 2 and 5, so $TN = 2$ . Truth 0 but prediction 1 is a false positive, only at position 6, so $FP = 1$ .
Truth 1 but prediction 0 is a false negative, at position 3, so $FN = 1$ . Truth 1 and prediction 1 is a true positive, at positions 1 and 4, so $TP = 2$ .
Check: every example lands in exactly one cell, and $2 + 1 + 1 + 2 = 6$ .
Output: rows are the actual class and columns the predicted class, giving [[2, 1], [1, 2]]. Notice that row 1 sums to 3, the number of actual 0s, and the diagonal $TN + TP = 4$ counts the correct predictions, an accuracy of $4/6 \approx 0.667$ .

Constraints

y_true and y_pred are lists of 0s and 1s of equal length
Return a 2D list [[TN, FP], [FN, TP]]

Learn this in

Model EvaluationML Study Plan Text ClassificationNLP Study Plan

More from Machine Learning 1

RBF Kernel Matrixhard Polynomial Kernelmedium Hinge Losseasy Linear Decision Boundaryeasy Gradient Boosting Residual Stephard

Concept primer

Background Knowledge

The confusion matrix is a fundamental concept in model evaluation, particularly for binary classification problems. It provides a summary of predictions against actual outcomes, helping to evaluate the performance of a machine learning model. The matrix itself is a 2x2 table that categorizes predictions into four types: True Positive (TP), True Negative (TN), False Positive (FP), and False Negative (FN). Understanding these categories is crucial for assessing the accuracy, precision, recall, and F1-score of a model.

In the context of binary classification, each instance is labeled as either 0 or 1, representing two distinct classes. The model predicts a label for each instance, and the confusion matrix compares these predictions against the actual labels. The diagonal elements of the matrix, TP and TN, represent correct predictions, while the off-diagonal elements, FP and FN, represent incorrect predictions. This matrix is essential for identifying the strengths and weaknesses of a model, such as its tendency to overpredict or underpredict certain classes.

The confusion matrix is closely related to other evaluation metrics, such as accuracy, precision, recall, and the F1-score. These metrics can be calculated directly from the confusion matrix, providing a more detailed understanding of the model's performance. For example, accuracy is the ratio of correct predictions (TP + TN) to the total number of instances, while precision is the ratio of TP to the sum of TP and FP.

Algorithm/Approach

The general approach to building a confusion matrix involves iterating through the lists of true labels and predicted labels, comparing each pair of labels, and incrementing the corresponding cell in the matrix. This process can be implemented using a simple loop or by utilizing vectorized operations in languages like Python.

Step-by-Step Strategy

To implement the solution:

Initialize a 2x2 matrix with zeros, representing the confusion matrix.
Iterate through the lists of true labels and predicted labels simultaneously.
For each pair of labels, compare the true label with the predicted label and update the corresponding cell in the matrix.
After iterating through all pairs of labels, return the completed confusion matrix.

Common Pitfalls

When implementing the solution, watch out for:

Incorrectly initializing the matrix or updating the wrong cells.
Failing to handle edge cases, such as empty lists of labels.
Not validating the input lists to ensure they have the same length and contain only binary labels (0 or 1).

Time & Space Complexity

The expected time complexity is O(n), where n is the length of the input lists, since we need to iterate through each pair of labels once. The space complexity is O(1), as we only need to store the 2x2 confusion matrix, regardless of the size of the input lists.

solution.py

Python 3.13

Test results