📉 MÓDULO 4: "Métricas que Importam: Além da Acurácia"

Objetivo:

Entender que a acurácia não é tudo. Aprender a escolher, calcular e interpretar métricas apropriadas com base no problema—especialmente em contextos desbalanceados como detecção de fraudes.

4.1 A Armadilha da Acurácia

Imagine um conjunto de dados de fraudes:

• 99% transações legítimas
• 1% transações fraudulentas

Um modelo que sempre prevê "NÃO FRAUDE" terá 99% de acurácia… mas é inútil! Detecta ZERO fraudes.

4.2 Matriz de Confusão: Sua Melhor Amiga

A matriz de confusão mostra:

• Verdadeiros Positivos (VP): Fraudes corretamente detectadas.
• Falsos Negativos (FN): Fraudes que o modelo rotulou como legítimas (erro grave!).
• Falsos Positivos (FP): Transações legítimas marcadas como fraudes (incômodo ao cliente).
• Verdadeiros Negativos (VN): Transações legítimas corretamente identificadas.

from sklearn.metrics import confusion_matrix
import seaborn as sns

y_pred = modelo.predict(X_test)
cm = confusion_matrix(y_test, y_pred)

sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=['Legítimo', 'Fraude'],
            yticklabels=['Legítimo', 'Fraude'])
plt.title("Matriz de Confusão")
plt.ylabel("Real")
plt.xlabel("Previsto")
plt.show()

4.3 Precisão, Revocação e Pontuação F1

➤ Precisão

De todas as transações que marquei como fraude, quantas eram realmente fraudes?

Precisão = VP / (VP + FP)

✅ Importante quando o custo de falso positivo é alto (ex., bloquear um cartão legítimo).

➤ Revocação (Sensibilidade, Taxa de Verdadeiros Positivos)

De todas as fraudes reais, quantas eu detectei?

Revocação = VP / (VP + FN)

✅ CRÍTICA na detecção de fraudes. Você quer minimizar FN (fraudes não detectadas).

➤ Pontuação F1

Média harmônica de precisão e revocação. Útil quando se busca equilíbrio.

F1 = 2 * (Precisão * Revocação) / (Precisão + Revocação)

from sklearn.metrics import precision_score, recall_score, f1_score

print("Precisão:", precision_score(y_test, y_pred))
print("Revocação:   ", recall_score(y_test, y_pred))
print("Pontuação F1: ", f1_score(y_test, y_pred))

4.4 AUC-ROC: O Padrão Ouro para Classificação Binária

A curva ROC mostra a compensação entre Taxa de Verdadeiros Positivos (Revocação) e Taxa de Falsos Positivos em vários limites de decisão.

AUC (Área Sob a Curva) é um número entre 0 e 1:

• 0.5 = modelo aleatório
• 1.0 = modelo perfeito

from sklearn.metrics import roc_auc_score, roc_curve

y_proba = modelo.predict_proba(X_test)[:, 1]  # probabilidade da classe positiva
auc = roc_auc_score(y_test, y_proba)
print("AUC-ROC:", auc)

# Plotar curva
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
plt.plot(fpr, tpr, label=f'Curva ROC (AUC = {auc:.2f})')
plt.plot([0,1], [0,1], 'k--', label='Classificador Aleatório')
plt.xlabel('Taxa de Falsos Positivos')
plt.ylabel('Taxa de Verdadeiros Positivos')
plt.title('Curva ROC')
plt.legend()
plt.grid()
plt.show()

✅ Vantagem da AUC: Invariante ao desequilíbrio de classes. Perfeita para fraudes.

4.5 Relatório Completo de Classificação

Scikit-learn fornece um resumo profissional:

from sklearn.metrics import classification_report

print(classification_report(y_test, y_pred,
      target_names=['Legítimo', 'Fraude']))

Saída típica:

              precision    recall  f1-score   support

   Legítimo       0.99      1.00      0.99     19800
     Fraude       0.85      0.50      0.63       200

    accuracy                           0.99     20000
   macro avg       0.92      0.75      0.81     20000
weighted avg       0.99      0.99      0.99     20000

📝 Exercício 4.1: Avaliação Profunda em um Conjunto de Dados Desbalanceado

Conjunto de dados: fraude_preprocessada.csv (pré-processado do módulo anterior)

Tarefas:

1. Treinar um modelo de Regressão Logística.
2. Calcular e exibir a matriz de confusão.
3. Calcular precisão, revocação, pontuação F1 e AUC-ROC.
4. Interpretar resultados: O modelo é bom? Qual métrica importa mais aqui e por quê?
5. Ajustar o limite de decisão (padrão 0.5) para melhorar a revocação (mesmo que a precisão piorar). Usar predict_proba e um limite de 0.3.
6. Comparar métricas antes e depois do ajuste de limite.

💡 Notas Adicionais:

• Em fraudes, revocação > precisão. É melhor revisar manualmente alguns casos legítimos (FP) do que deixar uma fraude passar (FN).
• AUC-ROC é sua melhor aliada para comparar modelos em conjuntos de dados desbalanceados.
• Nunca use acurácia como métrica principal em problemas desbalanceados.
• Scikit-learn tem precision_recall_curve para plotar a compensação precisão-revocação (útil quando os negativos são maioria).