Python：如何用列表从混淆矩阵提取FP/TP？二分类模型评估求助

Got it, let’s break this down step by step—calculating false positives, true positives, and other confusion matrix metrics for your Random Forest and Decision Tree models is straightforward, and I’ll walk you through both a manual implementation (to understand the logic) and a quick scikit-learn approach (for production use).

First, let’s align on the core terms for binary classification (assuming your positive class is 1 and negative is 0):

• True Positives (TP): Model predicts 1, actual label is 1
• True Negatives (TN): Model predicts 0, actual label is 0
• False Positives (FP): Model predicts 1, actual label is 0 (Type I error)
• False Negatives (FN): Model predicts 0, actual label is 1 (Type II error)

Option 1: Manual Implementation (Great for Learning the Logic) #

This function will take your true labels and predicted labels, compute all four core metrics, plus common derived metrics like accuracy, precision, and recall. It uses numpy for fast vectorized operations:

import numpy as np

def calculate_confusion_metrics(true_labels, pred_labels):
    # Convert inputs to numpy arrays for consistent handling
    true_labels = np.array(true_labels)
    pred_labels = np.array(pred_labels)
    
    # Calculate core confusion matrix values
    TP = np.sum((true_labels == 1) & (pred_labels == 1))
    TN = np.sum((true_labels == 0) & (pred_labels == 0))
    FP = np.sum((true_labels == 0) & (pred_labels == 1))
    FN = np.sum((true_labels == 1) & (pred_labels == 0))
    
    # Calculate derived performance metrics (with division-by-zero safeguards)
    total_samples = TP + TN + FP + FN
    accuracy = (TP + TN) / total_samples if total_samples != 0 else 0
    precision = TP / (TP + FP) if (TP + FP) != 0 else 0
    recall = TP / (TP + FN) if (TP + FN) != 0 else 0
    f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) != 0 else 0
    
    # Return results as a readable dictionary
    return {
        "TP": TP,
        "TN": TN,
        "FP": FP,
        "FN": FN,
        "accuracy": round(accuracy, 4),
        "precision": round(precision, 4),
        "recall": round(recall, 4),
        "f1_score": round(f1_score, 4)
    }

How to Use This Function #

Test it with your model predictions like this:

# Example true labels and model predictions
true_labels = [0, 1, 1, 0, 1, 0, 0, 1]
rf_predictions = [0, 1, 0, 0, 1, 1, 0, 1]  # Random Forest outputs
dt_predictions = [0, 1, 1, 0, 0, 0, 0, 1]  # Decision Tree outputs

# Get metrics for Random Forest
rf_results = calculate_confusion_metrics(true_labels, rf_predictions)
print("Random Forest Metrics:")
for metric, value in rf_results.items():
    print(f"- {metric}: {value}")

# Get metrics for Decision Tree
dt_results = calculate_confusion_metrics(true_labels, dt_predictions)
print("\nDecision Tree Metrics:")
for metric, value in dt_results.items():
    print(f"- {metric}: {value}")

Option 2: Use Scikit-Learn (For Quick, Production-Ready Results) #

If you don’t want to build the function from scratch, scikit-learn has built-in tools to compute the confusion matrix and a full classification report:

from sklearn.metrics import confusion_matrix, classification_report

# Generate confusion matrix for Random Forest
rf_confusion = confusion_matrix(true_labels, rf_predictions)
print("Random Forest Confusion Matrix:")
print(rf_confusion)
# Note: The matrix is formatted as [[TN, FP], [FN, TP]]

# Generate full classification report (includes precision, recall, F1)
print("\nRandom Forest Classification Report:")
print(classification_report(true_labels, rf_predictions))

Key Tips for Comparing Your Models #

• Align labels first: Make sure your true and predicted labels use the same encoding (e.g., don’t mix 0/1 with "negative"/"positive" unless you map them consistently).
• Focus on relevant metrics: If minimizing false positives is critical (e.g., fraud detection), prioritize models with lower FP counts and higher precision. If reducing false negatives matters more (e.g., disease screening), look for higher recall.
• Avoid over-reliance on accuracy: For imbalanced datasets, accuracy can be misleading—precision/recall or F1-score are better indicators of model performance.

内容的提问来源于stack exchange，提问作者John_Rodgers