ROC com Validação Cruzada

Introdução

Neste laboratório, aprenderemos a estimar e visualizar a variância da métrica Receiver Operating Characteristic (ROC) usando validação cruzada em Python. As curvas ROC são usadas na classificação binária para medir o desempenho de um modelo, plotando a taxa de verdadeiros positivos (TPR) contra a taxa de falsos positivos (FPR). Usaremos a biblioteca Scikit-learn para carregar o conjunto de dados iris, criar recursos ruidosos e classificar o conjunto de dados com a Máquina de Vetores de Suporte (SVM). Em seguida, plotaremos as curvas ROC com validação cruzada e calcularemos a média da Área Sob a Curva (AUC) para ver a variabilidade da saída do classificador quando o conjunto de treinamento é dividido em diferentes subconjuntos.

Dicas da Máquina Virtual

Após o término do inicialização da VM, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.

Carregar e preparar os dados

Primeiro, carregaremos o conjunto de dados iris usando a biblioteca Scikit-learn. O conjunto de dados iris contém 3 classes de plantas de íris, e binarizarmos o conjunto de dados descartando uma classe para criar um problema de classificação binária. Também adicionaremos recursos ruidosos para tornar o problema mais difícil.

import numpy as np
from sklearn.datasets import load_iris

iris = load_iris()
target_names = iris.target_names
X, y = iris.data, iris.target
X, y = X[y != 2], y[y != 2]
n_samples, n_features = X.shape

## adicionar recursos ruidosos
random_state = np.random.RandomState(0)
X = np.concatenate([X, random_state.randn(n_samples, 200 * n_features)], axis=1)

Classificação e análise ROC

Em seguida, executaremos um classificador SVM com validação cruzada e plotaremos as curvas ROC por dobra. Usaremos StratifiedKFold do Scikit-learn para gerar as divisões de validação cruzada. Também calcularemos a AUC média das curvas ROC e veremos a variabilidade da saída do classificador plotando o desvio padrão dos TPRs.

import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.metrics import auc
from sklearn.metrics import RocCurveDisplay
from sklearn.model_selection import StratifiedKFold

n_splits = 6
cv = StratifiedKFold(n_splits=n_splits)
classifier = svm.SVC(kernel="linear", probability=True, random_state=random_state)

tprs = []
aucs = []
mean_fpr = np.linspace(0, 1, 100)

fig, ax = plt.subplots(figsize=(6, 6))
for fold, (train, test) in enumerate(cv.split(X, y)):
    classifier.fit(X[train], y[train])
    viz = RocCurveDisplay.from_estimator(
        classifier,
        X[test],
        y[test],
        name=f"ROC fold {fold}",
        alpha=0.3,
        lw=1,
        ax=ax,
        plot_chance_level=(fold == n_splits - 1),
    )
    interp_tpr = np.interp(mean_fpr, viz.fpr, viz.tpr)
    interp_tpr[0] = 0.0
    tprs.append(interp_tpr)
    aucs.append(viz.roc_auc)

mean_tpr = np.mean(tprs, axis=0)
mean_tpr[-1] = 1.0
mean_auc = auc(mean_fpr, mean_tpr)
std_auc = np.std(aucs)
ax.plot(
    mean_fpr,
    mean_tpr,
    color="b",
    label=r"ROC média (AUC = %0.2f $\pm$ %0.2f)" % (mean_auc, std_auc),
    lw=2,
    alpha=0.8,
)

std_tpr = np.std(tprs, axis=0)
tprs_upper = np.minimum(mean_tpr + std_tpr, 1)
tprs_lower = np.maximum(mean_tpr - std_tpr, 0)
ax.fill_between(
    mean_fpr,
    tprs_lower,
    tprs_upper,
    color="grey",
    alpha=0.2,
    label=r"$\pm$ 1 desvio padrão",
)

ax.set(
    xlim=[-0.05, 1.05],
    ylim=[-0.05, 1.05],
    xlabel="Taxa de Falsos Positivos",
    ylabel="Taxa de Verdadeiros Positivos",
    title=f"Curva ROC média com variabilidade\n(rótulo positivo '{target_names[1]}')",
)
ax.axis("square")
ax.legend(loc="lower right")
plt.show()

Resumo

Neste laboratório, aprendemos como estimar e visualizar a variância da métrica Receiver Operating Characteristic (ROC) usando validação cruzada em Python. Carregamos o conjunto de dados iris, criamos recursos ruidosos e classificamos o conjunto de dados com SVM. Em seguida, plotamos as curvas ROC com validação cruzada e calculamos a AUC média para observar a variabilidade da saída do classificador quando o conjunto de treinamento é dividido em diferentes subconjuntos. As curvas ROC podem nos ajudar a avaliar o desempenho de um classificador binário e a ver o trade-off entre verdadeiros positivos e falsos positivos. A validação cruzada pode nos ajudar a estimar a variabilidade da saída do classificador e escolher o melhor modelo para nosso problema.