Classification Metrics

from sklearn.metrics import confusion_matrix

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

cm = confusion_matrix(y_true, y_pred)
print("Confusion Matrix:")
print(cm)

tn, fp, fn, tp = cm.ravel()
print(f"\nTP: {tp}, TN: {tn}, FP: {fp}, FN: {fn}")

from sklearn.metrics import confusion_matrix
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, random_state=42
)

model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

cm = confusion_matrix(y_test, y_pred)
print("Multi-class Confusion Matrix:")
print(cm)
print(f"\nClasses: {iris.target_names}")

# Given values
TN, FP, FN, TP = 85, 5, 3, 7

# Calculate all metrics
accuracy = (TP + TN) / (TP + TN + FP + FN)
precision = TP / (TP + FP)
recall = TP / (TP + FN)
f1 = 2 * (precision * recall) / (precision + recall)
specificity = TN / (TN + FP)

print(f"Total samples: {TP + TN + FP + FN}")
print(f"\nAccuracy: {accuracy:.2%}")
print(f"Precision: {precision:.2%}")
print(f"Recall (Sensitivity): {recall:.2%}")
print(f"Specificity: {specificity:.2%}")
print(f"F1 Score: {f1:.2%}")

# Verify with sklearn
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import numpy as np

y_true = [0]*TN + [0]*FP + [1]*FN + [1]*TP
y_pred = [0]*TN + [1]*FP + [0]*FN + [1]*TP

print(f"\nVerification with sklearn:")
print(f"Accuracy: {accuracy_score(y_true, y_pred):.2%}")

import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix
import numpy as np

def plot_confusion_matrix(y_true, y_pred, labels=None):
    """Plot a beautiful confusion matrix heatmap"""
    cm = confusion_matrix(y_true, y_pred)
    
    plt.figure(figsize=(8, 6))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
                xticklabels=labels or ['Negative', 'Positive'],
                yticklabels=labels or ['Negative', 'Positive'])
    plt.xlabel('Predicted Label')
    plt.ylabel('True Label')
    plt.title('Confusion Matrix')
    
    # Add totals
    total = cm.sum()
    correct = np.trace(cm)
    print(f"Total samples: {total}")
    print(f"Correct predictions: {correct}")
    print(f"Accuracy: {correct/total:.1%}")
    
    plt.tight_layout()
    plt.show()

# Example usage
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, random_state=42)

model = LogisticRegression(max_iter=5000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

plot_confusion_matrix(y_test, y_pred, labels=['Malignant', 'Benign'])

import numpy as np
from sklearn.metrics import confusion_matrix

# Example: Cancer detection results
y_true = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]  # 5 healthy, 5 sick
y_pred = [0, 0, 0, 1, 1, 1, 1, 1, 0, 0]  # Model predictions

cm = confusion_matrix(y_true, y_pred)
tn, fp, fn, tp = cm.ravel()

print("Confusion Matrix:")
print(cm)
print(f"\n--- Error Analysis ---")
print(f"Type I Errors (False Positives): {fp}")
print(f"  -> Healthy people told they have cancer")
print(f"  -> Causes: Unnecessary stress, extra tests")

print(f"\nType II Errors (False Negatives): {fn}")
print(f"  -> Sick people told they're healthy")
print(f"  -> Causes: Delayed treatment, could be FATAL!")

print(f"\n--- For Medical Diagnosis ---")
print(f"Type II errors (FN) are MUCH WORSE!")
print(f"Missing a cancer case could cost a life.")
print(f"A false alarm just means more tests.")
print(f"\nConclusion: Optimize for HIGH RECALL (catch all cancers)")

TP, FP, FN = 80, 20, 10

precision = TP / (TP + FP)
recall = TP / (TP + FN)

print(f"Precision: {precision:.2%}")  # 80%
print(f"Recall: {recall:.2%}")        # 88.9%

from sklearn.metrics import precision_recall_curve

precisions, recalls, thresholds = precision_recall_curve(y_test, y_proba)

# Find threshold for 90% recall
target_recall = 0.90
valid_idx = recalls >= target_recall
if valid_idx.any():
    best_idx = np.argmax(precisions[:-1][valid_idx[:-1]])
    best_threshold = thresholds[valid_idx[:-1]][best_idx]
    print(f"Threshold: {best_threshold:.3f}")
    print(f"Precision: {precisions[:-1][valid_idx[:-1]][best_idx]:.3f}")
    print(f"Recall: {recalls[:-1][valid_idx[:-1]][best_idx]:.3f}")

from sklearn.metrics import precision_score, recall_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

# Create dataset
X, y = make_classification(n_samples=1000, weights=[0.8, 0.2], 
                           random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# Train model
model = LogisticRegression()
model.fit(X_train, y_train)
y_proba = model.predict_proba(X_test)[:, 1]

# Show trade-off at different thresholds
print("Threshold | Precision | Recall | Predicted Pos")
print("-" * 50)

for thresh in [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]:
    y_pred = (y_proba >= thresh).astype(int)
    
    # Handle edge case of no positive predictions
    if sum(y_pred) == 0:
        prec = 0
    else:
        prec = precision_score(y_test, y_pred)
    
    rec = recall_score(y_test, y_pred)
    n_pos = sum(y_pred)
    
    print(f"   {thresh:.1f}     |   {prec:.2f}    |  {rec:.2f}   |     {n_pos}")

print("\nNotice: Lower threshold = More positives = Higher recall, Lower precision")

# Spam Filter Analysis
precision = 0.95
recall = 0.70

print("=== Spam Filter Performance Analysis ===")
print(f"\nPrecision: {precision:.0%}")
print("  What it means: When the filter marks an email as spam,")
print("  it's correct 95% of the time.")
print("  Only 5% of 'spam' emails are actually legitimate (false positives).")

print(f"\nRecall: {recall:.0%}")
print("  What it means: Of all actual spam emails,")
print("  the filter catches 70% of them.")
print("  30% of spam emails slip through to your inbox (false negatives).")

print("\n=== Is this good for a spam filter? ===")
print("YES, this is EXCELLENT for a spam filter!")
print("\nWhy?")
print("1. HIGH PRECISION (95%) is critical for spam filters")
print("   - Losing important emails is VERY bad")
print("   - Missing a job offer or contract is worse than seeing some spam")
print("\n2. Lower recall (70%) is acceptable")
print("   - Seeing some spam in inbox is annoying but not harmful")
print("   - Users can manually delete spam that gets through")
print("\nFor spam filters: PRECISION > RECALL")

from sklearn.metrics import precision_score, classification_report
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Load 3-class dataset
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, random_state=42)

model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Different averaging methods
print("=== Precision Averaging Methods ===")
print(f"\nMacro (simple average):    {precision_score(y_test, y_pred, average='macro'):.3f}")
print("  -> Each class counts equally")

print(f"\nWeighted (by class size):  {precision_score(y_test, y_pred, average='weighted'):.3f}")
print("  -> Larger classes have more influence")

print(f"\nMicro (total TP / total P): {precision_score(y_test, y_pred, average='micro'):.3f}")
print("  -> Treats all samples equally")

print("\n=== Full Classification Report ===")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

precision = 0.8
recall = 0.6

f1 = 2 * (precision * recall) / (precision + recall)
print(f"F1 Score: {f1:.3f}")  # 0.686

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score, balanced_accuracy_score

X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

model = LogisticRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

print(f"F1 Score: {f1_score(y_test, y_pred):.3f}")
print(f"Balanced Accuracy: {balanced_accuracy_score(y_test, y_pred):.3f}")

# Extreme case: Perfect precision, terrible recall
precision = 1.0   # 100% - every positive prediction is correct
recall = 0.01     # 1% - we only found 1% of actual positives!

# Arithmetic mean (simple average)
arithmetic_mean = (precision + recall) / 2
print(f"Arithmetic Mean: {arithmetic_mean:.2%}")  # 50.5%

# Harmonic mean (F1 score)
f1 = 2 * (precision * recall) / (precision + recall)
print(f"F1 Score (Harmonic Mean): {f1:.2%}")  # 1.98%

print("\n=== Why F1 is Better ===")
print(f"\nThe model catches only {recall:.0%} of positives!")
print("This is a TERRIBLE model - it misses 99% of cases.")
print("\nArithmetic mean of 50.5% is MISLEADING.")
print("It makes the model look acceptable when it's useless.")
print("\nF1 of 1.98% correctly shows the model is BAD.")
print("The harmonic mean punishes extreme values.")
print("\nRule: F1 is only high when BOTH precision AND recall are high.")

from sklearn.metrics import fbeta_score
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Create dataset
X, y = make_classification(n_samples=1000, weights=[0.9, 0.1], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

model = LogisticRegression().fit(X_train, y_train)
y_pred = model.predict(X_test)

# Calculate different F-beta scores
f05 = fbeta_score(y_test, y_pred, beta=0.5)  # Precision-focused
f1 = fbeta_score(y_test, y_pred, beta=1.0)   # Balanced
f2 = fbeta_score(y_test, y_pred, beta=2.0)   # Recall-focused

print("=== F-beta Scores ===")
print(f"\nF0.5 (Precision-focused): {f05:.3f}")
print("  Use when: False positives are costly")
print("  Examples: Spam detection, recommendation systems")

print(f"\nF1 (Balanced): {f1:.3f}")
print("  Use when: Both errors are equally bad")
print("  Examples: General classification, balanced datasets")

print(f"\nF2 (Recall-focused): {f2:.3f}")
print("  Use when: False negatives are costly")
print("  Examples: Cancer detection, fraud detection")

print("\n=== The Formula ===")
print("F-beta = (1 + β²) × (precision × recall) / (β² × precision + recall)")
print("\nHigher beta = More weight on recall")
print("Lower beta = More weight on precision")

import numpy as np
from sklearn.metrics import matthews_corrcoef, f1_score

# Confusion matrix values
TP, TN, FP, FN = 8, 900, 10, 2  # Highly imbalanced!

# Manual MCC calculation
numerator = (TP * TN) - (FP * FN)
denominator = np.sqrt((TP + FP) * (TP + FN) * (TN + FP) * (TN + FN))
mcc_manual = numerator / denominator

print("=== Matthews Correlation Coefficient ===")
print(f"\nTP={TP}, TN={TN}, FP={FP}, FN={FN}")
print(f"Total samples: {TP+TN+FP+FN}")
print(f"Class imbalance: {TN+FP} negative vs {TP+FN} positive")

print(f"\nMCC (manual): {mcc_manual:.3f}")

# Verify with sklearn
y_true = [0]*TN + [0]*FP + [1]*FN + [1]*TP
y_pred = [0]*TN + [1]*FP + [0]*FN + [1]*TP
print(f"MCC (sklearn): {matthews_corrcoef(y_true, y_pred):.3f}")
print(f"F1 Score: {f1_score(y_true, y_pred):.3f}")

print("\n=== Why MCC is Better ===")
print("1. Uses ALL four values (TP, TN, FP, FN)")
print("2. F1 ignores True Negatives!")
print("3. MCC ranges from -1 to +1:")
print("   +1 = perfect prediction")
print("    0 = random prediction")
print("   -1 = total disagreement")
print("\n4. MCC only gives high score when model does well")
print("   on BOTH classes, not just the positive class.")

from sklearn.metrics import roc_auc_score
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression

# Binary classification (setosa vs others)
iris = load_iris()
X, y = iris.data, (iris.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

model = LogisticRegression().fit(X_train, y_train)
y_proba = model.predict_proba(X_test)[:, 1]

auc = roc_auc_score(y_test, y_proba)
print(f"ROC-AUC: {auc:.3f}")

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score

models = {
    'Logistic Regression': LogisticRegression(max_iter=1000),
    'Decision Tree': DecisionTreeClassifier(random_state=42),
    'Random Forest': RandomForestClassifier(random_state=42)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    y_proba = model.predict_proba(X_test)[:, 1]
    auc = roc_auc_score(y_test, y_proba)
    print(f"{name}: AUC = {auc:.3f}")

import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve, roc_auc_score
import numpy as np

# Assume model and data are ready
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, random_state=42)

model = LogisticRegression(max_iter=5000)
model.fit(X_train, y_train)
y_proba = model.predict_proba(X_test)[:, 1]

# Calculate ROC curve
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
auc = roc_auc_score(y_test, y_proba)

# Find optimal threshold (Youden's J statistic)
j_scores = tpr - fpr
optimal_idx = np.argmax(j_scores)
optimal_threshold = thresholds[optimal_idx]

print(f"AUC: {auc:.3f}")
print(f"Optimal Threshold: {optimal_threshold:.3f}")
print(f"At this threshold:")
print(f"  TPR (Recall): {tpr[optimal_idx]:.3f}")
print(f"  FPR: {fpr[optimal_idx]:.3f}")

# Plot ROC curve
plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, 'b-', linewidth=2, label=f'ROC (AUC = {auc:.3f})')
plt.plot([0, 1], [0, 1], 'k--', label='Random (AUC = 0.5)')
plt.scatter(fpr[optimal_idx], tpr[optimal_idx], 
            color='red', s=100, zorder=5,
            label=f'Optimal (threshold={optimal_threshold:.2f})')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve with Optimal Threshold')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

from sklearn.metrics import roc_auc_score, average_precision_score
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Create HIGHLY imbalanced dataset (5% positive)
X, y = make_classification(n_samples=2000, weights=[0.95, 0.05],
                           n_features=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

model = LogisticRegression()
model.fit(X_train, y_train)
y_proba = model.predict_proba(X_test)[:, 1]

# Calculate both metrics
roc_auc = roc_auc_score(y_test, y_proba)
avg_precision = average_precision_score(y_test, y_proba)

print("=== Imbalanced Dataset Analysis ===")
print(f"Positive class: {sum(y_test)} out of {len(y_test)} ({sum(y_test)/len(y_test):.1%})")
print(f"\nROC-AUC: {roc_auc:.3f}")
print(f"Average Precision (PR-AUC): {avg_precision:.3f}")

print("\n=== Why the Difference? ===")
print("\nROC-AUC looks HIGH because:")
print("  - It includes True Negatives")
print("  - With many negatives, getting TNs right is easy")
print("  - This 'inflates' the ROC-AUC score")

print("\nPR-AUC looks LOWER because:")
print("  - It focuses ONLY on the positive class")
print("  - Ignores True Negatives completely")
print("  - Shows how well we find the rare positives")

print("\n=== Recommendation ===")
print("For imbalanced data, TRUST PR-AUC more!")
print("It gives a more realistic view of performance.")

auc = 0.85

print("=== Explaining AUC to Your Manager ===")
print(f"\nOur fraud detection model has AUC = {auc}")
print("\nWhat does this mean in simple terms?")
print("="*50)

print(f"\n1. THE RANKING TEST:")
print(f"   If I pick one fraudulent transaction and one normal one,")
print(f"   our model will correctly identify which is fraud")
print(f"   {auc:.0%} of the time.")

print(f"\n2. THE QUALITY SCALE:")
print(f"   - AUC = 0.5 = Random guessing (coin flip)")
print(f"   - AUC = 0.7-0.8 = Acceptable")
print(f"   - AUC = 0.8-0.9 = Good (← We are HERE)")
print(f"   - AUC = 0.9-1.0 = Excellent")
print(f"   - AUC = 1.0 = Perfect")

print(f"\n3. PRACTICAL MEANING:")
print(f"   Our model is performing WELL.")
print(f"   It successfully distinguishes fraud from normal transactions")
print(f"   much better than random chance.")

print(f"\n4. ROOM FOR IMPROVEMENT:")
print(f"   We're at 85%, so there's still 15% where the model")
print(f"   ranks a normal transaction higher than a fraud.")
print(f"   We could try more features or better algorithms.")

from sklearn.metrics import *

def evaluate_classifier(y_true, y_pred, y_proba=None):
    metrics = {
        'accuracy': accuracy_score(y_true, y_pred),
        'precision': precision_score(y_true, y_pred),
        'recall': recall_score(y_true, y_pred),
        'f1': f1_score(y_true, y_pred),
        'balanced_acc': balanced_accuracy_score(y_true, y_pred),
        'mcc': matthews_corrcoef(y_true, y_pred)
    }
    if y_proba is not None:
        metrics['roc_auc'] = roc_auc_score(y_true, y_proba)
        metrics['avg_precision'] = average_precision_score(y_true, y_proba)
    return metrics

# Usage
results = evaluate_classifier(y_test, y_pred, y_proba)
for name, score in results.items():
    print(f"{name}: {score:.3f}")

scenarios = [
    {
        "name": "Airport Security (detecting weapons)",
        "metric": "RECALL",
        "reason": "Missing a weapon could be fatal. False alarms are inconvenient but acceptable."
    },
    {
        "name": "YouTube Recommendation System",
        "metric": "PRECISION",
        "reason": "Recommending irrelevant videos annoys users. Missing some good videos is fine."
    },
    {
        "name": "Credit Card Fraud Detection",
        "metric": "F1 or F2 (recall-weighted)",
        "reason": "Missing fraud is costly, but too many false alarms block legitimate purchases."
    },
    {
        "name": "Email Spam Filter",
        "metric": "PRECISION (or F0.5)",
        "reason": "Sending important emails to spam is very bad. Some spam in inbox is tolerable."
    },
    {
        "name": "Autonomous Car Pedestrian Detection",
        "metric": "RECALL (near 100%)",
        "reason": "Missing a pedestrian could kill someone. False braking is safe."
    },
    {
        "name": "Product Defect Detection in Factory",
        "metric": "RECALL",
        "reason": "Shipping defective products damages brand reputation and safety."
    }
]

print("=== Metric Selection for Real-World Scenarios ===")
for s in scenarios:
    print(f"\n📌 {s['name']}")
    print(f"   Best Metric: {s['metric']}")
    print(f"   Why: {s['reason']}")

import numpy as np
from sklearn.metrics import confusion_matrix
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

def calculate_cost(y_true, y_pred, fn_cost=500, fp_cost=5):
    """
    Calculate total cost of classification errors.
    
    In fraud detection:
    - FN (missed fraud): Customer loses money, bank pays = HIGH COST
    - FP (blocked transaction): Customer inconvenienced = LOW COST
    """
    cm = confusion_matrix(y_true, y_pred)
    tn, fp, fn, tp = cm.ravel()
    
    total_cost = (fn * fn_cost) + (fp * fp_cost)
    
    print(f"Confusion Matrix:")
    print(f"  TN={tn}, FP={fp}")
    print(f"  FN={fn}, TP={tp}")
    print(f"\nCost Breakdown:")
    print(f"  FN cost: {fn} × ${fn_cost} = ${fn * fn_cost}")
    print(f"  FP cost: {fp} × ${fp_cost} = ${fp * fp_cost}")
    print(f"  Total Cost: ${total_cost}")
    
    return total_cost

# Example with fraud detection
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# Compare two models with different thresholds
model = LogisticRegression()
model.fit(X_train, y_train)
y_proba = model.predict_proba(X_test)[:, 1]

print("=== Model 1: Default threshold (0.5) ===")
y_pred_default = (y_proba >= 0.5).astype(int)
cost1 = calculate_cost(y_test, y_pred_default)

print("\n=== Model 2: Lower threshold (0.3) - catches more fraud ===")
y_pred_lower = (y_proba >= 0.3).astype(int)
cost2 = calculate_cost(y_test, y_pred_lower)

print(f"\n=== Comparison ===")
print(f"Savings by using lower threshold: ${cost1 - cost2}")

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import (accuracy_score, precision_score, recall_score,
                            f1_score, roc_auc_score)
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import pandas as pd

# Load cancer detection data
data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, random_state=42)

# Define models
models = {
    'Logistic Regression': LogisticRegression(max_iter=5000),
    'Decision Tree': DecisionTreeClassifier(random_state=42),
    'Random Forest': RandomForestClassifier(random_state=42),
}

# Evaluate each model
results = []
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    y_proba = model.predict_proba(X_test)[:, 1]
    
    results.append({
        'Model': name,
        'Accuracy': accuracy_score(y_test, y_pred),
        'Precision': precision_score(y_test, y_pred),
        'Recall': recall_score(y_test, y_pred),
        'F1': f1_score(y_test, y_pred),
        'ROC-AUC': roc_auc_score(y_test, y_proba)
    })

# Display comparison table
df = pd.DataFrame(results)
print("=== Model Comparison Table ===")
print(df.to_string(index=False))

# Recommendation for cancer detection
print("\n=== Recommendation for Cancer Detection ===")
print("For cancer detection, we prioritize RECALL!")
print("We must catch ALL cancer cases, even at the cost of some false alarms.")
best_recall_model = df.loc[df['Recall'].idxmax(), 'Model']
print(f"\nBest model by Recall: {best_recall_model}")