Python Academy · Aula

Avaliação de modelos e validação cruzada

Avalie modelos com acurácia, F1, ROC-AUC e CV em k partições.

Avaliação de modelos e validação cruzada é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Divisão em treinamento, validação e teste

Use uma divisão em três partes: o treinamento serve para ajustar o modelo, a validação para ajustar os hiperparâmetros e o teste para informar o desempenho final. Nunca use o conjunto de teste durante o desenvolvimento.

from sklearn.model_selection import train_test_split
import numpy as np

X = np.random.rand(1000, 10)
y = (X[:,0] > 0.5).astype(int)

X_tr, X_rest, y_tr, y_rest = train_test_split(X, y, test_size=0.3)
X_val, X_te, y_val, y_te = train_test_split(X_rest, y_rest, test_size=0.5)

Pontuação de acurácia

accuracy_score é a fração de previsões corretas. Use-a para classes equilibradas; para dados desbalanceados, prefira F1 ou AUC.

from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = LogisticRegression().fit(X_tr, y_tr)
print("Accuracy:", accuracy_score(y_te, model.predict(X_te)))

Precisão, revocação e F1

Para classes desbalanceadas: precisão = TP/(TP+FP), revocação = TP/(TP+FN), F1 = média harmônica da precisão e da revocação.

from sklearn.metrics import precision_score, recall_score, f1_score, classification_report

# Use classification_report for a full summary:
print(classification_report(y_te, model.predict(X_te)))
# shows precision, recall, f1 for each class

Matriz de confusão

Uma matriz de confusão mostra verdadeiros positivos, falsos positivos, verdadeiros negativos e falsos negativos.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

cm = confusion_matrix(y_te, model.predict(X_te))
print(cm)
# [[TN FP]
#  [FN TP]]

Curva ROC e AUC

roc_auc_score mede a área sob a curva ROC. AUC = 1.0 é perfeito; 0.5 = aleatório.

from sklearn.metrics import roc_auc_score, roc_curve

y_prob = model.predict_proba(X_te)[:,1]
print("AUC:", roc_auc_score(y_te, y_prob))

fpr, tpr, thresholds = roc_curve(y_te, y_prob)
# plot fpr vs tpr for the full ROC curve

Métricas de regressão

Use mean_squared_error (MSE), root_mean_squared_error (RMSE) e r2_score para tarefas de regressão.

from sklearn.metrics import mean_squared_error, r2_score

y_pred = regression_model.predict(X_te)
mse = mean_squared_error(y_te, y_pred)
print("RMSE:", mse**0.5)
print("R²:", r2_score(y_te, y_pred))

Validação cruzada em k partições

cross_val_score divide os dados em k partições, treina em k-1, avalia em 1 e repete o processo k vezes. É mais robusta do que uma única divisão.

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(random_state=0)
scores = cross_val_score(LogisticRegression(), X, y, cv=10, scoring="accuracy")
print(f"{scores.mean():.3f} ± {scores.std():.3f}")

StratifiedKFold

Use StratifiedKFold para garantir que cada partição tenha a mesma distribuição de classes — algo essencial para conjuntos de dados desbalanceados.

from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(weights=[0.9,0.1], random_state=0)
cv = StratifiedKFold(n_splits=5)
scores = cross_val_score(LogisticRegression(), X, y, cv=cv, scoring="f1")
print("Stratified F1:", scores.mean())

Compromisso entre viés e variância

Viés alto = subajuste (modelo simples demais). Variância alta = sobreajuste (modelo complexo demais). A validação cruzada revela qual desses problemas está presente.

# Underfitting: low train score AND low val score
# → increase model complexity, add features

# Overfitting: high train score, low val score
# → regularise, reduce complexity, get more data

from sklearn.model_selection import validation_curve
import numpy as np

train_sc, val_sc = validation_curve(DecisionTreeClassifier(), X, y, param_name="max_depth", param_range=range(1,10))

Validação cruzada aninhada

Para obter ajuste de hiperparâmetros AND avaliação sem viés, use validação cruzada aninhada: o laço interno ajusta e o laço externo avalia.

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.svm import SVC
from sklearn.datasets import make_classification

X, y = make_classification(random_state=0)
gs = GridSearchCV(SVC(), {"C":[0.1,1,10]}, cv=5)
outer_scores = cross_val_score(gs, X, y, cv=5)
print("Nested CV accuracy:", outer_scores.mean())

Calibração

As estimativas de probabilidade de um classificador podem estar mal calibradas. Use CalibratedClassifierCV para obter estimativas de probabilidade melhores.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y)

cal = CalibratedClassifierCV(SVC(), cv=5).fit(X_tr, y_tr)
print(cal.predict_proba(X_te[:3]))

Verificação rápida

Por que a validação cruzada é preferível a uma única divisão entre treinamento e teste para avaliar modelos?

Recapitulação

Use a acurácia em problemas equilibrados; F1/AUC em problemas desbalanceados. Avalie com cross_val_score em k partições, use StratifiedKFold para dados desbalanceados e use validação cruzada aninhada ao ajustar hiperparâmetros, a fim de obter uma estimativa final sem viés. Nunca consulte o conjunto de teste durante o desenvolvimento.

Perguntas Frequentes

A aula “Avaliação de modelos e validação cruzada” é grátis?

Sim — o texto completo de “Avaliação de modelos e validação cruzada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Avaliação de modelos e validação cruzada”?

Avalie modelos com acurácia, F1, ROC-AUC e CV em k partições. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Avaliação de modelos e validação cruzada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

A API do scikit-learn: fit, transform, predict
Modelos lineares: regressão e classificação
Modelos baseados em árvores: árvores de decisão e florestas aleatórias
Avaliação de modelos e validação cruzada

← Voltar para Python Academy