Overfitting, validação cruzada e pipelines

O maior perigo em Machine Learning é criar um modelo que vai muito bem nos dados que já viu e mal nos dados novos. Esta aula mostra como detectar esse problema e as ferramentas do scikit-learn para evitá-lo.

Overfitting e underfitting

• Overfitting (sobreajuste): o modelo é complexo demais e decora o treino, incluindo o ruído. Vai bem no treino e mal no teste.
• Underfitting (subajuste): o modelo é simples demais e não captura o padrão. Vai mal nos dois.

O sinal clássico de overfitting é uma grande diferença entre a nota no treino e a nota no teste. Veja com árvores de várias profundidades:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

X, y = load_breast_cancer(return_X_y=True)
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

for profundidade in [1, 2, 3, 5, 10, None]:
    arvore = DecisionTreeClassifier(max_depth=profundidade, random_state=42)
    arvore.fit(X_treino, y_treino)
    nota_treino = arvore.score(X_treino, y_treino)
    nota_teste = arvore.score(X_teste, y_teste)
    print(profundidade, round(nota_treino, 3), round(nota_teste, 3))

Com max_depth=None (sem limite) a nota no treino chega a 1.0, a árvore acerta tudo o que já viu, mas a nota no teste não acompanha. Com profundidade 1 as duas notas são baixas (underfitting). O ponto ideal fica no meio.

Validação cruzada

Uma única divisão treino/teste pode dar sorte ou azar. Na validação cruzada (cross-validation) os dados são divididos em k partes; o modelo treina em k - 1 delas e testa na restante, repetindo até todas as partes terem sido teste uma vez.

from sklearn.model_selection import cross_val_score

notas = cross_val_score(DecisionTreeClassifier(max_depth=3, random_state=42),
                        X, y, cv=5)

print(notas)                            # 5 notas, uma por divisão
print(notas.mean(), notas.std())        # média e variação

A média dá uma estimativa mais confiável, e o desvio padrão mostra o quanto o resultado é estável.

Pipelines: pré-processamento sem vazamento

Lembra que KNN e outros modelos são sensíveis à escala? O StandardScaler padroniza cada feature (média 0 e desvio 1). Mas há uma armadilha: se você padronizar todos os dados antes de dividir, a média e o desvio do teste “vazam” para o treino. É o chamado vazamento de dados (data leakage), que deixa a avaliação otimista demais.

A solução é o Pipeline, que encadeia os passos e garante que o pré-processamento aprenda só com os dados de treino de cada divisão:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

pipeline = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5))

notas = cross_val_score(pipeline, X, y, cv=5)
print(notas.mean())

Escolhendo hiperparâmetros com GridSearchCV

Em vez de testar valores na mão, o GridSearchCV testa todas as combinações que você listar, usando validação cruzada em cada uma:

from sklearn.model_selection import GridSearchCV

parametros = {"max_depth": [2, 3, 4, 5, 8, None]}

busca = GridSearchCV(DecisionTreeClassifier(random_state=42), parametros, cv=5)
busca.fit(X_treino, y_treino)

print(busca.best_params_)    # a melhor combinação encontrada
print(busca.best_score_)     # a nota média dela na validação cruzada
print(busca.score(X_teste, y_teste))   # avaliação final no teste

Exercícios