A Beginner's Guide to Precision, Recall, F1 Score, and True Positives

 

Precision

Precision is the ratio of correctly predicted positive observations to the total predicted positives. It answers the question: "Of all the positive predictions, how many were actually correct?"

Precision=True Positives (TP)True Positives (TP)+False Positives (FP)\text{Precision} = \frac{\text{True Positives (TP)}}{\text{True Positives (TP)} + \text{False Positives (FP)}}

Example: Imagine you have a model that predicts whether an email is spam. Out of 100 emails predicted as spam, 80 are actually spam, and 20 are not (false positives).

Precision=8080+20=80100=0.8\text{Precision} = \frac{80}{80 + 20} = \frac{80}{100} = 0.8

So, the precision is 0.8, or 80%.

Recall (Sensitivity)

Recall is the ratio of correctly predicted positive observations to all the observations in the actual class. It answers the question: "Of all the actual positives, how many did we correctly predict?"

Recall=True Positives (TP)True Positives (TP)+False Negatives (FN)\text{Recall} = \frac{\text{True Positives (TP)}}{\text{True Positives (TP)} + \text{False Negatives (FN)}}

Example: Continuing with the spam email example, suppose there are 90 actual spam emails in the dataset, and your model correctly identified 80 of them, missing 10 (false negatives).

Recall=8080+10=8090≈0.89\text{Recall} = \frac{80}{80 + 10} = \frac{80}{90} \approx 0.89

So, the recall is approximately 0.89, or 89%.

F1 Score

The F1 score is the harmonic mean of precision and recall. It provides a balance between precision and recall, especially useful when you need a single metric to evaluate the model's performance.

F1 Score=2×Precision×RecallPrecision+Recall\text{F1 Score} = 2 \times \frac{\text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}}

Example: Using the precision of 0.8 and recall of 0.89 from the previous examples:

F1 Score=2×0.8×0.890.8+0.89≈2×0.7121.69≈0.843\text{F1 Score} = 2 \times \frac{0.8 \times 0.89}{0.8 + 0.89} \approx 2 \times \frac{0.712}{1.69} \approx 0.843

So, the F1 score is approximately 0.843, or 84.3%.

True Positive (TP)

A true positive is an outcome where the model correctly predicts the positive class. In the context of binary classification (spam vs. not spam), a true positive means the model correctly identifies a spam email as spam.

Example: If your model correctly identifies 80 spam emails as spam, those 80 are your true positives.

Summary with Example

Let's consolidate these metrics with a confusion matrix for the spam email example:

  • True Positives (TP): 80 (spam correctly identified as spam)
  • False Positives (FP): 20 (non-spam incorrectly identified as spam)
  • False Negatives (FN): 10 (spam incorrectly identified as non-spam)
  • True Negatives (TN): Suppose there are 200 actual non-spam emails, and your model correctly identifies 180 of them. So, TN = 180.

From this, we get

These metrics help you evaluate your model's performance in a more nuanced way than simply looking at overall accuracy.

Comments

Post a Comment

Popular posts from this blog

Mastering the Difference Array Technique: A Simple Guide with Examples

Image
Introduction Have you ever encountered a problem where you need to update multiple ranges in an array efficiently? Updating each element one by one can be too slow , especially for large datasets. This is where the Difference Array Technique comes in! It allows us to perform range updates in O(1) time per update and compute the final array efficiently. In this blog, we’ll break it down with step-by-step explanations and visuals to make it super easy to understand. Understanding the Problem Let’s say we have an array: A = [ 0 , 0 , 0 , 0 , 0 ] A = [0, 0, 0, 0, 0] A = [ 0 , 0 , 0 , 0 , 0 ] We want to perform multiple operations like: 1️⃣ Add 10 to indices [1 to 3] 2️⃣ Add 5 to indices [2 to 4] 3️⃣ Add 20 to indices [0 to 2] A naive approach would be to loop through each range and update elements one by one , which takes O(n) per operation . For large arrays and multiple queries, this becomes very inefficient ! 🚨 What is the Difference Array? Instead of updating each ele...
Read more

Leetcode 2594. Minimum Time to Repair Cars explained clearly

When solving problems efficiently, choosing the right strategy makes all the difference. A common comparison in programming is Binary Search vs. Brute Force (or the Naïve approach ). While brute force might seem straightforward, it often becomes impractical for large inputs. Binary search, on the other hand, is a game-changer. Let's break it down in simple terms. 1. Understanding Brute Force (Naïve Approach) Imagine you have a book with 1,000 pages and you are looking for a particular word. If you start from page 1 and check each page one by one, that’s the brute force approach . This method works but is slow because you have to go through every single page before finding what you need. In coding, brute force means trying all possible solutions until you find the correct one. While this approach is easy to understand, it is very slow when the number of possibilities is huge. Example: Car Repair Problem Let’s say you have mechanics who can repair cars, and you want to find ou...
Read more

Finding a Unique Binary String in Python

IntroductionImagine you are given a list of binary strings, and your task is to find a new binary string that is not present in the list. This might seem tricky at first, but Python makes it easy to solve. In this guide, we'll break down the problem step by step and understand how to implement a simple and efficient solution. Understanding the ProblemYou are given a list of n binary strings, each of length n. Your goal is to find a new n-bit binary string that is not present in the list. Example:nums = ["00", "01", "10"] Output: "11" (since "11" is not in the list) There can be multiple valid answers. The key is to ensure that the generated binary string is unique. here is my approach to solve  from typing import List class Solution :     def findDifferentBinaryString ( self , nums : List[ str ]) -> str :         n = len (nums)         num_set = set (nums)         for i in range ( 2 **n):     ...
Read more