Przejdź do głównej zawartości

advanced_metrics

czym są zaawansowane metryki? ⭐​

  • Zaawansowane metryki to bardziej wyrafinowane sposoby oceny modeli ML.
  • Wykraczają poza podstawowe metryki jak accuracy, precision, recall.
  • Uwzględniają różne aspekty wydajności modelu.
  • Są szczególnie przydatne dla niezbalansowanych danych i specyficznych problemów.
  • Pomagają w lepszym zrozumieniu zachowania modelu.

typy zaawansowanych metryk ⭐​

1. Metryki probabilistyczne​

  • ROC-AUC (Area Under ROC Curve)
  • Precision-Recall AUC
  • Log Loss
  • Brier Score

2. Metryki rankingowe​

  • Mean Average Precision (MAP)
  • Normalized Discounted Cumulative Gain (NDCG)
  • Mean Reciprocal Rank (MRR)

3. Metryki biznesowe​

  • Cost-sensitive metrics
  • Custom business metrics
  • ROI-based metrics

4. Metryki interpretacyjne​

  • Calibration metrics
  • Confidence metrics
  • Uncertainty quantification

przykładowy kod (zaawansowane metryki)​

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score, average_precision_score, log_loss
from sklearn.metrics import roc_curve, precision_recall_curve
from sklearn.calibration import calibration_curve
import matplotlib.pyplot as plt
import seaborn as sns

# Generowanie danych
np.random.seed(42)
n_samples = 2000

# Generowanie cech
feature1 = np.random.normal(0, 1, n_samples)
feature2 = np.random.normal(0, 1, n_samples)

# Tworzenie niezbalansowanego targetu
class_0_mask = np.random.choice([True, False], n_samples, p=[0.8, 0.2])
class_1_mask = ~class_0_mask

# Modyfikacja cech dla klasy 1
feature1[class_1_mask] += 1.5
feature2[class_1_mask] += 1.5

# Target
y = class_1_mask.astype(int)

# Tworzenie DataFrame
data = pd.DataFrame({
    'feature1': feature1,
    'feature2': feature2,
    'target': y
})

# Podział danych
X = data[['feature1', 'feature2']]
y = data['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# Trenowanie modelu
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

# Przewidywania
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test)[:, 1]

print("Podstawowe metryki:")
print(f"Accuracy: {np.mean(y_pred == y_test):.3f}")

1. ROC-AUC i krzywa ROC​

# ROC-AUC
roc_auc = roc_auc_score(y_test, y_pred_proba)
print(f"ROC-AUC: {roc_auc:.3f}")

# Krzywa ROC
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)

plt.figure(figsize=(12, 4))

plt.subplot(1, 3, 1)
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.legend(loc="lower right")
plt.grid(True)

2. Precision-Recall AUC​

# Precision-Recall AUC
pr_auc = average_precision_score(y_test, y_pred_proba)
print(f"Precision-Recall AUC: {pr_auc:.3f}")

# Krzywa Precision-Recall
precision, recall, _ = precision_recall_curve(y_test, y_pred_proba)

plt.subplot(1, 3, 2)
plt.plot(recall, precision, color='blue', lw=2, label=f'PR curve (AUC = {pr_auc:.3f})')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.title('Precision-Recall Curve')
plt.legend()
plt.grid(True)

3. Log Loss​

# Log Loss
log_loss_score = log_loss(y_test, y_pred_proba)
print(f"Log Loss: {log_loss_score:.3f}")

# Porównanie z innymi modelami
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

models = {
    'Random Forest': RandomForestClassifier(random_state=42),
    'Logistic Regression': LogisticRegression(random_state=42),
    'SVM': SVC(probability=True, random_state=42)
}

log_loss_scores = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred_proba_model = model.predict_proba(X_test)[:, 1]
    log_loss_scores[name] = log_loss(y_test, y_pred_proba_model)

print("\nLog Loss dla różnych modeli:")
for name, score in log_loss_scores.items():
    print(f"{name}: {score:.3f}")

4. Kalibracja modelu​

# Kalibracja
fraction_of_positives, mean_predicted_value = calibration_curve(y_test, y_pred_proba, n_bins=10)

plt.subplot(1, 3, 3)
plt.plot(mean_predicted_value, fraction_of_positives, "s-", label="Model")
plt.plot([0, 1], [0, 1], "k:", label="Perfectly calibrated")
plt.xlabel('Mean Predicted Probability')
plt.ylabel('Fraction of Positives')
plt.title('Calibration Plot')
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()

5. Metryki biznesowe​

# Przykład: Cost-sensitive metrics
# Koszty różnych typów błędów
cost_fp = 10  # Koszt fałszywego pozytywnego
cost_fn = 50  # Koszt fałszywego negatywnego

# Obliczanie kosztów
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
tn, fp, fn, tp = cm.ravel()

total_cost = fp * cost_fp + fn * cost_fn
cost_per_prediction = total_cost / len(y_test)

print(f"\nMetryki biznesowe:")
print(f"Koszt całkowity: {total_cost}")
print(f"Koszt na predykcję: {cost_per_prediction:.2f}")

# Custom business metric
def custom_business_metric(y_true, y_pred_proba, threshold=0.5):
    """Customowa metryka biznesowa"""
    y_pred = (y_pred_proba > threshold).astype(int)
    
    # Przykład: ważona kombinacja precision i recall
    precision = precision_score(y_true, y_pred, zero_division=0)
    recall = recall_score(y_true, y_pred, zero_division=0)
    
    # Waga recall wyższa (ważniejsze wykrycie pozytywnych)
    business_score = 0.3 * precision + 0.7 * recall
    return business_score

business_score = custom_business_metric(y_test, y_pred_proba)
print(f"Custom business score: {business_score:.3f}")

6. Metryki rankingowe (dla problemów rankingowych)​

# Przykład dla problemu rankingowego
def mean_reciprocal_rank(y_true, y_pred_proba, k=5):
    """Mean Reciprocal Rank dla top-k predykcji"""
    # Sortowanie predykcji
    sorted_indices = np.argsort(y_pred_proba)[::-1][:k]
    
    # Znalezienie pozycji pierwszej pozytywnej predykcji
    for i, idx in enumerate(sorted_indices):
        if y_true[idx] == 1:
            return 1.0 / (i + 1)
    
    return 0.0

# Przykład użycia
mrr_score = mean_reciprocal_rank(y_test, y_pred_proba, k=5)
print(f"Mean Reciprocal Rank (top-5): {mrr_score:.3f}")

7. Metryki niepewności​

# Obliczanie niepewności predykcji
def prediction_uncertainty(y_pred_proba):
    """Niepewność predykcji na podstawie prawdopodobieństw"""
    # Im bliżej 0.5, tym większa niepewność
    uncertainty = 1 - np.abs(y_pred_proba - 0.5) * 2
    return uncertainty

uncertainty_scores = prediction_uncertainty(y_pred_proba)
avg_uncertainty = np.mean(uncertainty_scores)

print(f"\nMetryki niepewności:")
print(f"Średnia niepewność: {avg_uncertainty:.3f}")
print(f"Liczba niepewnych predykcji (>0.5): {np.sum(uncertainty_scores > 0.5)}")

praktyczne ćwiczenia​

  1. Porównaj metryki - przetestuj różne metryki na tym samym modelu.

  2. Threshold optimization - znajdź optymalny próg dla różnych metryk.

  3. Custom metrics - stwórz własne metryki biznesowe.

  4. Calibration - popraw kalibrację modelu.

  5. Uncertainty quantification - zaimplementuj metody oceny niepewności.

dobre praktyki​

  • Wybór metryki: Dostosuj metrykę do problemu biznesowego.
  • Interpretacja: Zrozum, co oznacza każda metryka.
  • Walidacja: Używaj cross-validation z zaawansowanymi metrykami.
  • Monitoring: Śledź metryki w czasie.

polecane źródła​