Calculating Precision, Recall and F-score in one pass – python

By jacksparrow September 5, 2024

Calculating Precision, Recall and F-score in one pass – Python

In machine learning, particularly in classification tasks, evaluating the performance of a model is crucial. Precision, recall, and F-score are common metrics used to assess the accuracy of a classification model. This article discusses how to calculate these metrics efficiently in one pass using Python.

Understanding the Metrics

Precision

Precision measures the proportion of correctly predicted positive cases out of all cases predicted as positive. It’s a measure of how accurate the model is when it predicts a positive class.

Recall

Recall measures the proportion of correctly predicted positive cases out of all actual positive cases. It’s a measure of how well the model is able to identify all the positive cases.

F-score

The F-score is a harmonic mean of precision and recall. It provides a single metric that balances both precision and recall.

Calculating in One Pass

Traditionally, calculating these metrics involves separate iterations over the data. However, we can optimize the process by performing the calculations in a single pass, improving efficiency and reducing computational cost.

Python Implementation

Let’s illustrate with a Python code example:



      # Sample data - true labels and predicted labels

      true_labels = [1, 0, 1, 1, 0, 1, 0, 0, 1, 1]

      predicted_labels = [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]
      # Initialize counters

      tp = 0  # True Positives

      fp = 0  # False Positives

      fn = 0  # False Negatives
      # Iterate through the data in a single pass

      for i in range(len(true_labels)):

        if true_labels[i] == 1 and predicted_labels[i] == 1:

          tp += 1

        elif true_labels[i] == 0 and predicted_labels[i] == 1:

          fp += 1

        elif true_labels[i] == 1 and predicted_labels[i] == 0:

          fn += 1
      # Calculate the metrics

      precision = tp / (tp + fp) if (tp + fp) > 0 else 0

      recall = tp / (tp + fn) if (tp + fn) > 0 else 0

      f_score = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0

# Print the results print(f"Precision: {precision:.4f}") print(f"Recall: {precision:.4f}") print(f"F-score: {f_score:.4f}")

Precision: 0.6667
Recall: 0.6667
F-score: 0.6667

In this example, we iterate through the true and predicted labels once. For each data point, we update the counters (TP, FP, FN) based on the correct and predicted classifications. Finally, we compute the precision, recall, and F-score using the updated counters.

Benefits

Improved efficiency: One pass over the data reduces computation time.
Reduced memory usage: Fewer variables are stored in memory during the process.
Scalability: The approach works well with large datasets.

Conclusion

Calculating precision, recall, and F-score in one pass offers several advantages, especially for large datasets. By iterating over the data just once and keeping track of the relevant counters, we can efficiently evaluate the performance of a classification model. This optimization leads to faster results and efficient memory usage.

Post Views: 10

Calculating Precision, Recall and F-score in one pass – python