Confusion matrix analysis in TensorFlow - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the function that computes a confusion matrix.

TensorFlow

from sklearn.metrics import [1]

Drag options to blanks, or click blank then click option'

Aaccuracy_score

Bconfusion_matrix

Cclassification_report

Droc_auc_score

Attempts:

3 left

💡 Hint

Common Mistakes

Importing accuracy_score instead of confusion_matrix

Using classification_report which summarizes metrics but does not return the matrix

Trying to import from tensorflow instead of sklearn.metrics

The confusion_matrix function from sklearn.metrics computes the confusion matrix for classification results.

2fill in blank

medium

Complete the code to compute the confusion matrix from true and predicted labels.

TensorFlow

cm = confusion_matrix([1], y_pred)

Drag options to blanks, or click blank then click option'

Apredictions

By_pred

Clabels

Dy_true

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping true and predicted labels

Using variable names that do not exist in the code

The first argument to confusion_matrix is the true labels, usually named y_true.

3fill in blank

hard

Fix the error in the code to display the confusion matrix as a heatmap using matplotlib.

TensorFlow

import matplotlib.pyplot as plt
import seaborn as sns
sns.heatmap([1], annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.show()

Drag options to blanks, or click blank then click option'

Acm

By_true

Cy_pred

Dconfusion_matrix

Attempts:

3 left

💡 Hint

Common Mistakes

Passing true or predicted labels instead of the matrix

Passing the function name instead of the matrix variable

The heatmap function needs the confusion matrix data, which is stored in the variable cm.

4fill in blank

hard

Fill both blanks to calculate precision and recall from the confusion matrix.

TensorFlow

precision = cm[[1], [2]] / cm[:, [2]].sum()

Drag options to blanks, or click blank then click option'

A1

B0

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong indices for true positives

Summing over rows instead of columns

Precision is calculated as true positives (row 1, col 1) divided by all predicted positives (sum of column 1).

5fill in blank

hard

Fill all three blanks to calculate recall from the confusion matrix.

TensorFlow

recall = cm[[1], [2]] / cm[[3], :].sum()

Drag options to blanks, or click blank then click option'

A1

B0

Attempts:

3 left

💡 Hint

Common Mistakes

Using column sums instead of row sums

Using wrong indices for true positives

Recall is true positives (row 1, col 1) divided by all actual positives (sum of row 1).

Practice

1. What does a confusion matrix primarily show in a classification problem?

easy

A. The number of correct and incorrect predictions for each class

B. The training time of the model

C. The number of features used in the model

D. The learning rate of the optimizer

Solution

1. Step 1: Understand the purpose of a confusion matrix

   A confusion matrix displays how many predictions were correct or wrong for each class in classification.

2. Step 2: Compare options with the definition

   Only The number of correct and incorrect predictions for each class correctly describes this purpose; others relate to unrelated model aspects.

3. Final Answer:

   The number of correct and incorrect predictions for each class -> Option A

4. Quick Check:

   Confusion matrix = correct/wrong counts [OK]

Hint: Confusion matrix counts correct vs wrong predictions per class [OK]

Common Mistakes:

• Confusing confusion matrix with training metrics like loss
• Thinking it shows model parameters
• Assuming it shows training time

2. Which TensorFlow function is used to compute a confusion matrix from true labels and predicted labels?

easy

A. tf.data.Dataset.from_tensor_slices()

B. tf.keras.metrics.Accuracy()

C. tf.math.confusion_matrix()

D. tf.nn.softmax()

Solution

1. Step 1: Identify TensorFlow functions related to confusion matrix

   The function tf.math.confusion_matrix() directly computes the confusion matrix from labels.

2. Step 2: Eliminate unrelated functions

   tf.keras.metrics.Accuracy() measures accuracy, tf.data.Dataset.from_tensor_slices() creates datasets, and tf.nn.softmax() applies softmax activation.

3. Final Answer:

   tf.math.confusion_matrix() -> Option C

4. Quick Check:

   Confusion matrix function = tf.math.confusion_matrix() [OK]

Hint: Use tf.math.confusion_matrix() for confusion matrix [OK]

Common Mistakes:

• Using accuracy metric instead of confusion matrix function
• Confusing dataset creation with confusion matrix
• Mixing activation functions with metrics

3. Given the following code, what is the output confusion matrix?

import tensorflow as tf
true_labels = [0, 1, 2, 2, 0]
pred_labels = [0, 2, 2, 2, 0]
cm = tf.math.confusion_matrix(true_labels, pred_labels)
print(cm.numpy())

medium

A. [[2 0 0]
[0 0 0]
[0 1 2]]

B. [[2 0 0]
[0 1 0]
[0 0 2]]

C. [[1 0 1]
[0 0 1]
[0 0 2]]

D. [[2 0 0]
[0 0 1]
[0 0 2]]

Solution

1. Step 1: Count true vs predicted labels for each class

   Class 0 true: predicted 0 twice; class 1 true: predicted 2 once; class 2 true: predicted 2 twice.

2. Step 2: Build confusion matrix rows

   Row 0: [2 correct (0 predicted as 0), 0 predicted as 1, 0 predicted as 2]; Row 1: [0, 0, 1]; Row 2: [0, 0, 2].

3. Final Answer:

   [[2 0 0] [0 0 1] [0 0 2]] -> Option D

4. Quick Check:

   Count matches matrix entries [OK]

Hint: Count true vs predicted labels per class to fill matrix [OK]

Common Mistakes:

• Mixing up rows and columns in the matrix
• Counting predicted labels instead of true labels
• Forgetting to count all instances

4. Identify the error in this TensorFlow code snippet for confusion matrix calculation:

import tensorflow as tf
true = [0, 1, 1, 0]
pred = [0, 1, 0]
cm = tf.math.confusion_matrix(true, pred)
print(cm)

medium

A. The confusion matrix function is misspelled

B. The true and predicted label lists have different lengths

C. TensorFlow is not imported correctly

D. The print statement is missing parentheses

Solution

1. Step 1: Check input list lengths

   True labels list has 4 elements; predicted labels list has 3 elements, causing mismatch.

2. Step 2: Understand function requirements

   tf.math.confusion_matrix() requires true and predicted labels to be same length to compare element-wise.

3. Final Answer:

   The true and predicted label lists have different lengths -> Option B

4. Quick Check:

   Input lengths must match [OK]

Hint: Ensure true and predicted label lists have same length [OK]

Common Mistakes:

• Ignoring length mismatch error
• Assuming function name typo
• Thinking print syntax is wrong in Python 3

5. You have a 3-class classification problem with classes 0, 1, and 2. After training, your confusion matrix is:

[[50  2  3]
 [ 4 45  1]
 [ 5  2 40]]

Which class has the highest precision, and how do you calculate it from the matrix?

hard

A. Class 1; precision = TP / (TP + FP) = 45 / (45 + 4 + 1)

B. Class 2; precision = TP / (TP + FP) = 40 / (3 + 1 + 40)

C. Class 0; precision = TP / (TP + FP) = 50 / (50 + 4 + 5)

D. Class 1; precision = TP / (TP + FP) = 45 / (2 + 45 + 2)

Solution

1. Step 1: Understand precision calculation

   Precision for a class = True Positives (TP) / (TP + False Positives (FP)). TP is diagonal element; FP is sum of column excluding TP.

2. Step 2: Calculate precision for each class

   Class 0: TP=50; FP=sum column 0 excluding TP=4+5=9; precision=50/(50+9)=50/59≈0.847. Class 1: TP=45; FP=2+2=4; precision=45/(45+4)=45/49≈0.918. Class 2: TP=40; FP=3+1=4; precision=40/(40+4)=40/44≈0.909.

3. Step 3: Identify highest precision

   Class 1 has the highest precision (≈0.918).

4. Final Answer:

   Class 1; precision = TP / (TP + FP) = 45 / (45 + 4 + 1) -> Option A

5. Quick Check:

   Precision = TP / (TP + FP) [OK]

Hint: Precision = TP / (TP + FP) using confusion matrix columns [OK]

Common Mistakes:

• Confusing precision with recall
• Using row sums instead of column sums for FP
• Mixing up TP and FP positions