O modelo que não faz nada
acerta 97,5%.

As páginas da aula tratam as métricas uma a uma. Este roteiro faz o contrário: pega um único problema e o percorre inteiro, do dado cru até a decisão, mostrando em cada passo qual número foi olhado e o que ele custou. As quatro perguntas, na ordem em que aparecem num projeto de verdade:

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(
    n_samples=20000, n_features=12, n_informative=5, n_redundant=2,
    weights=[0.98, 0.02], flip_y=0.01, class_sep=1.1, random_state=7)

X_tr, X_tmp, y_tr, y_tmp = train_test_split(X, y, test_size=0.4, random_state=0, stratify=y)
X_val, X_te, y_val, y_te = train_test_split(X_tmp, y_tmp, test_size=0.5, random_state=0, stratify=y_tmp)

print(y.mean(), y_te.sum(), len(y_te))
# 0.0248   99   4000

Repare no stratify=y: sem ele, uma partição aleatória de um conjunto com 2,5% de positivos produz partições com taxas base diferentes entre si, e aí todas as comparações do resto da aula ficam contaminadas por essa diferença.

O modelo desta aula é uma floresta aleatória, treinada uma vez e nunca mais tocada. O que muda daqui em diante é só onde cortamos a probabilidade que ela devolve:

Três modelos treinados nos mesmos dados: uma floresta aleatória, uma regressão logística e um naive bayes gaussiano. Primeiro pelas duas curvas:

O motivo está em qual erro cada curva mede. A ROC usa a taxa de falsos positivos, e o denominador dela são os 3 901 negativos — mil alertas falsos mexem pouco nessa fração. A precisão usa a contagem de falsos positivos contra a de verdadeiros, e nessa razão mil alertas falsos são a diferença entre um sistema útil e um inútil. Quando a classe positiva é rara, é a segunda conta que descreve a sua vida.

Suponha que revisar um alerta falso custe 5 e deixar passar uma fraude custe 250. Prever "fraude" vale a pena quando o prejuízo esperado de não prever supera o de prever:

A verificação é direta: agrupe as previsões por probabilidade declarada e veja com que frequência elas de fato acontecem. Um modelo calibrado cai sobre a diagonal. O ECE é a distância média até ela, ponderada pelo tamanho de cada faixa.

RMSE/MAE = 1,25 é o valor esperado para erro gaussiano bem comportado, e concorda com o gráfico de resíduos. Fosse 2 ou 3, a mesma tabela mereceria desconfiança: o erro estaria concentrado em poucos casos grandes, e o RMSE médio não descreveria nenhum paciente típico. O pior resíduo desta amostra é de 164,6 — três vezes o RMSE, num alvo cuja faixa é de 25 a 346.

1. Reproduza. Rode o código do apêndice B e confirme os números do bloco 3 (AUC 0,888 e AP 0,553 para a floresta). Se não bater, resolva isso antes de seguir.
2. Mude a taxa base. Refaça o conjunto com weights=[0.999, 0.001] — 0,1% de fraude. Meça AUC e AP de novo. Qual das duas se mexeu? Quanto? Escreva a razão AP / taxa base nos dois cenários.
3. Sua matriz de custo. Escolha um problema que você conhece (spam, triagem médica, moderação, crédito) e atribua custos aos dois erros. Calcule o limiar da fórmula, ache o mínimo empírico na validação, e reporte o quanto o 0,5 custaria.
4. Quebre a calibração. Treine um modelo que precise dela — GaussianNB, ou uma floresta bem rasa — e meça ECE antes e depois de Platt. Confirme que AUC e AP não mudaram nem na quarta casa.
5. Uma medida no teste. Escolha uma configuração final inteira (modelo + limiar + calibração) usando só a validação, meça no teste uma vez, e escreva as três frases que você colocaria num relatório: o número, contra qual linha de base, e com qual limiar e por quê.

MODELS = {}
for name, mdl, scaled in [
        ("floresta", RandomForestClassifier(n_estimators=200, min_samples_leaf=3, random_state=0), False),
        ("logística", LogisticRegression(max_iter=2000), True),
        ("naive bayes", GaussianNB(), True)]:
    m = mdl.fit(Z_tr if scaled else X_tr, y_tr)
    MODELS[name] = dict(
        val=m.predict_proba(Z_val if scaled else X_val)[:, 1],
        test=m.predict_proba(Z_te if scaled else X_te)[:, 1])

def counts(y_true, p, thr):
    pred = (p >= thr).astype(int)
    tp = int(((pred == 1) & (y_true == 1)).sum())
    fp = int(((pred == 1) & (y_true == 0)).sum())
    fn = int(((pred == 0) & (y_true == 1)).sum())
    tn = int(((pred == 0) & (y_true == 0)).sum())
    return tp, fp, fn, tn


def metrics(y_true, p, thr):
    tp, fp, fn, tn = counts(y_true, p, thr)
    prec = tp / (tp + fp) if tp + fp else 0.0
    rec = tp / (tp + fn) if tp + fn else 0.0
    f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0
    return dict(thr=thr, tp=tp, fp=fp, fn=fn, tn=tn, precision=prec, recall=rec, f1=f1,
                accuracy=(tp + tn) / len(y_true))


def platt(p_fit, y_fit, p_apply):
    """Escala de Platt: uma regressão logística sobre o próprio logit."""
    z = np.log(np.clip(p_fit, 1e-9, 1 - 1e-9) / (1 - np.clip(p_fit, 1e-9, 1 - 1e-9)))
    lr = LogisticRegression(max_iter=1000).fit(z.reshape(-1, 1), y_fit)
    za = np.log(np.clip(p_apply, 1e-9, 1 - 1e-9) / (1 - np.clip(p_apply, 1e-9, 1 - 1e-9)))
    return lr.predict_proba(za.reshape(-1, 1))[:, 1]


def reliability(p, y_true, bins=12):
    edges = np.linspace(0, 1, bins + 1)
    xs, ys, ns = [], [], []
    for lo, hi in zip(edges[:-1], edges[1:]):
        m = (p > lo) & (p <= hi)
        if m.sum() >= 10:
            xs.append(p[m].mean()); ys.append(y_true[m].mean()); ns.append(int(m.sum()))
    return np.array(xs), np.array(ys), np.array(ns)


def ece(p, y_true, bins=12):
    edges, e = np.linspace(0, 1, bins + 1), 0.0
    for lo, hi in zip(edges[:-1], edges[1:]):
        m = (p > lo) & (p <= hi)
        if m.sum():
            e += m.mean() * abs(y_true[m].mean() - p[m].mean())
    return float(e)

from sklearn.metrics import (average_precision_score, roc_auc_score,
                             precision_recall_curve, brier_score_loss)
from sklearn.calibration import CalibratedClassifierCV, calibration_curve

ap  = average_precision_score(y_val, p_val)     # a métrica do bloco 3
prec, rec, thr = precision_recall_curve(y_val, p_val)
cal = CalibratedClassifierCV(modelo, method="sigmoid", cv="prefit").fit(X_val, y_val)
x, y_ = calibration_curve(y_te, p_te, n_bins=12)   # a curva do bloco 5

Este handout acompanha as páginas de 8.1 Classificação e 8.2 Regressão, que trazem os simuladores interativos — inclusive um em que a temperatura de calibração se ajusta na sua frente, e outro com quatro modelos que compartilham o mesmo RMSE.