Avaliação de Modelos Scikit-learn

Introdução

Após treinar um modelo de machine learning, é crucial avaliar seu desempenho para entender o quão bem ele generaliza para dados novos e não vistos. Scikit-learn, uma poderosa biblioteca Python para machine learning, fornece um conjunto abrangente de ferramentas para avaliação de modelos em seu módulo sklearn.metrics.

Neste laboratório, você aprenderá a avaliar um modelo de classificação usando algumas das métricas mais comuns. Utilizaremos um conjunto predefinido de rótulos verdadeiros e rótulos previstos para focar exclusivamente no processo de avaliação. Você aprenderá a calcular:

• Accuracy Score (Pontuação de Acurácia)
• Confusion Matrix (Matriz de Confusão)
• Precision Score (Pontuação de Precisão)
• Recall Score (Pontuação de Revocação)
• F1 Score (Pontuação F1)

Ao final deste laboratório, você será proficiente no uso dessas funções fundamentais do scikit-learn para avaliar o desempenho de seus modelos de classificação.

Calcular a pontuação de acurácia usando accuracy_score de sklearn.metrics

Nesta etapa, calcularemos a acurácia das previsões do nosso modelo. A acurácia é uma das métricas de classificação mais diretas. Ela mede a proporção de instâncias corretamente previstas em relação ao número total de instâncias.

A função accuracy_score de sklearn.metrics calcula este valor. Ela recebe os rótulos verdadeiros e os rótulos previstos como argumentos.

Primeiro, abra o arquivo evaluate.py no explorador de arquivos à esquerda. O arquivo já contém as listas y_true e y_pred. Agora, adicione o seguinte código ao final do arquivo para importar a função accuracy_score, calcular a acurácia e imprimir o resultado.

from sklearn.metrics import accuracy_score

## Calculate accuracy
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Seu arquivo evaluate.py completo deve agora parecer com isto:

## In this lab, we will use a predefined set of true labels and predicted labels
## to understand different evaluation metrics.

## y_true represents the actual, ground truth labels for our data points.
## For a binary classification, 0 could mean 'negative' and 1 could mean 'positive'.
y_true = [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]

## y_pred represents the labels predicted by our hypothetical classification model.
y_pred = [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]

print("Setup complete. True and predicted labels are defined in evaluate.py.")
print(f"True labels:    {y_true}")
print(f"Predicted labels: {y_pred}")

from sklearn.metrics import accuracy_score

## Calculate accuracy
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Agora, vamos executar o script. Abra o terminal em seu IDE e execute o seguinte comando:

python3 evaluate.py

Você deverá ver a seguinte saída, que inclui a pontuação de acurácia. Uma acurácia de 0.8 significa que 80% das previsões foram corretas.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8

Gerar matriz de confusão com confusion_matrix de sklearn.metrics

Nesta etapa, geraremos uma matriz de confusão. Embora a acurácia forneça um resumo rápido do desempenho, ela pode ser enganosa, especialmente para conjuntos de dados desbalanceados. Uma matriz de confusão fornece uma análise mais detalhada do desempenho de um classificador, mostrando o número de previsões corretas e incorretas para cada classe.

A matriz é uma tabela com quatro combinações de valores previstos e reais:

• Verdadeiros Negativos (TN - True Negatives): O modelo previu corretamente a classe negativa.
• Falsos Positivos (FP - False Positives): O modelo previu incorretamente a classe positiva.
• Falsos Negativos (FN - False Negatives): O modelo previu incorretamente a classe negativa.
• Verdadeiros Positivos (TP - True Positives): O modelo previu corretamente a classe positiva.

Usaremos a função confusion_matrix de sklearn.metrics. Adicione o seguinte código ao final do seu arquivo evaluate.py.

from sklearn.metrics import confusion_matrix

## Generate confusion matrix
cm = confusion_matrix(y_true, y_pred)

print("Confusion Matrix:")
print(cm)

Agora, execute o script novamente no terminal:

python3 evaluate.py

A saída agora incluirá a matriz de confusão.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]

Esta matriz nos diz:

• TN = 4 (Canto superior esquerdo)
• FP = 1 (Canto superior direito)
• FN = 1 (Canto inferior esquerdo)
• TP = 4 (Canto inferior direito)

Calcular a pontuação de precisão usando precision_score de sklearn.metrics

Nesta etapa, calcularemos a pontuação de precisão. A precisão responde à pergunta: "De todas as instâncias que o modelo previu como positivas, qual proporção foi realmente positiva?" É uma medida da exatidão de um classificador.

A precisão é calculada como: Precisão = Verdadeiros Positivos / (Verdadeiros Positivos + Falsos Positivos)

Uma baixa precisão indica um alto número de falsos positivos. Usaremos a função precision_score de sklearn.metrics.

Adicione o seguinte código ao final do seu arquivo evaluate.py para calcular e imprimir a precisão.

from sklearn.metrics import precision_score

## Calculate precision
precision = precision_score(y_true, y_pred)

print(f"Precision: {precision}")

Execute o script no terminal:

python3 evaluate.py

Você verá a pontuação de precisão adicionada à saída. Com base em nossa matriz de confusão (TP=4, FP=1), a precisão é 4 / (4 + 1) = 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8

Calcular a pontuação de recall usando recall_score de sklearn.metrics

Nesta etapa, calcularemos a pontuação de recall. Recall, também conhecido como sensibilidade ou taxa de verdadeiros positivos, responde à pergunta: "De todas as instâncias positivas reais, qual proporção o modelo identificou corretamente?" É uma medida da completude de um classificador.

O recall é calculado como: Recall = Verdadeiros Positivos / (Verdadeiros Positivos + Falsos Negativos)

Um recall baixo indica um alto número de falsos negativos. Usaremos a função recall_score de sklearn.metrics.

Adicione o seguinte código ao final do seu arquivo evaluate.py.

from sklearn.metrics import recall_score

## Calculate recall
recall = recall_score(y_true, y_pred)

print(f"Recall: {recall}")

Execute o script no terminal:

python3 evaluate.py

A saída agora incluirá a pontuação de recall. Com base em nossa matriz de confusão (TP=4, FN=1), o recall é 4 / (4 + 1) = 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8

Calcular a pontuação F1 usando f1_score de sklearn.metrics

Nesta etapa final, calcularemos a pontuação F1. A pontuação F1 é a média harmônica da precisão e do recall. Ela busca encontrar um equilíbrio entre as duas. Enquanto a precisão se concentra em minimizar os falsos positivos e o recall em minimizar os falsos negativos, a pontuação F1 fornece uma única métrica que considera ambas.

A pontuação F1 é calculada como: Pontuação F1 = 2 * (Precisão * Recall) / (Precisão + Recall)

É particularmente útil quando você precisa de um equilíbrio entre precisão e recall e quando há uma distribuição de classes desigual. Usaremos a função f1_score de sklearn.metrics.

Adicione a última parte do código ao seu arquivo evaluate.py.

from sklearn.metrics import f1_score

## Calculate F1 score
f1 = f1_score(y_true, y_pred)

print(f"F1 Score: {f1}")

Execute o script pela última vez no terminal:

python3 evaluate.py

A saída final exibirá todas as métricas que calculamos. Com uma precisão e recall de 0.8, a pontuação F1 também será 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8
F1 Score: 0.8

Resumo

Parabéns por completar o laboratório! Você aprendeu com sucesso a avaliar um modelo de classificação usando várias métricas chave da biblioteca scikit-learn.

Neste laboratório, você praticou:

• Calcular a acurácia com accuracy_score para ter uma noção geral do desempenho do modelo.
• Gerar uma matriz de confusão com confusion_matrix para obter uma visão detalhada de verdadeiros/falsos positivos e negativos.
• Calcular a precisão com precision_score para medir a exatidão do modelo.
• Calcular o recall com recall_score para medir a completude do modelo.
• Calcular a pontuação F1 com f1_score para encontrar um equilíbrio entre precisão e recall.

Essas métricas são ferramentas fundamentais para qualquer cientista de dados ou engenheiro de machine learning. Compreendê-las permite diagnosticar melhor os pontos fortes e fracos do seu modelo e escolher o modelo certo para o seu problema específico.